#include <bits/stdc++.h>
using namespace std;
// #include <ext/pb_ds/priority_queue.hpp>
// #include <ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
#define ordered_multiset tree<int, null_type, less_equal<int>, rb_tree_tag, tree_order_statistics_node_update>
/* ordered_set notes:
    .order_of_key(k): Number of items strictly smaller than k
    .find_by_order(k): k-th element in a set
*/
#define X first
#define Y second
template <typename A, typename B> istream& operator >> (istream& o, pair<A, B> &a) {
    return o >> a.X >> a.Y;
}
template <typename A, typename B> ostream& operator << (ostream& o, pair<A, B> a) {
    return o << '(' << a.X << ", " << a.Y << ')';
}
#ifdef cychien
#define DE(...) do {\
	fprintf(stderr, "%s - %d : (%s) = ", __PRETTY_FUNCTION__, __LINE__, #__VA_ARGS__);\
    _DO(__VA_ARGS__);\
}while(0) 
template<typename I> void _DO(I&&x) {cerr << x << '\n';}
template<typename I, typename ...T> void _DO(I&&x,T&&...tail) {cerr << x << ", "; _DO(tail...);}
#define IOS
#define debug(v) {cerr << #v << " = ["; for(auto it = (v).begin(); it != (v).end(); it++){cerr << *it; if (next(it) != (v).end()) cerr << ", "; } cerr << "]\n";}
#else
#define DE(...)
#define debug(v)  
#define IOS ios_base::sync_with_stdio(0);cin.tie(0)
#endif
#define W(v) {for(auto it = (v).begin(); it != (v).end(); it++)cout << *it << " \n"[next(it) == (v).end()];}
#define pb emplace_back
#define mp make_pair
#define rsz resize
#define SZ(x) (ll)x.size()
#define AI(x) (x).begin(),(x).end()
#define SORT(x) sort(AI(x))
template<class T> bool chmin(T &a, T b) { return b < a && (a = b, true); }
template<class T> bool chmax(T &a, T b) { return a < b && (a = b, true); }
typedef long long int ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
const int NF = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const ll MOD = 1e9 + 7;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int Rand(){
    return uniform_int_distribution<int>(INT_MIN, INT_MAX)(rng);
}
/*
#include <atcoder/all>
using namespace atcoder;
*/

/* LazySegtree

// Example for range linear transfromation & range sum
// Monoid Property: op(F(a), F(b)) == F(op(a, b))
// Declaration: lazy_segtree<S, op, e, F, mapping, composition, id> seg(n);

struct S { // Node
    mint sum;
    int len;
};
S op(S x, S y){ // pull
    return S{x.sum + y.sum, x.len + y.len};
}
S e(){ // e s.t. op(x, e) == x
    return S{0, 1};
}
 
struct F {
    mint a, b;
};
S mapping(F t, S x){ // push
    return S{t.a * x.sum + t.b * x.len, x.len};
}
F composition(F f, F g){ // f o g
    return F{f.a * g.a, f.a * g.b + f.b};
}
F id() { // id s.t. composition(F, id) == F
    return F{1, 0};
}

*/
typedef pair<long double, long double> pdd;
const long double eps = 1e-12;
pdd operator+(const pdd& A, const pdd& B){
    return make_pair(A.X + B.X, A.Y + B.Y);
}
pdd operator-(const pdd& A, const pdd& B){
    return make_pair(A.X - B.X, A.Y - B.Y);
}
long double operator*(const pdd& A, const pdd& B){
    return A.X * B.X + A.Y * B.Y;
}
long double norm2(pdd p){
    return p.X * p.X + p.Y * p.Y;
}
long double dist(const pdd& A, const pdd& B){
    return sqrtl(norm2(A - B));
}
pdd operator*(long double &rho, const pdd& P){
    return make_pair(rho * P.X, rho * P.Y);
}
void solve(){
    pdd M[4], P[4];
    for (int i = 0; i < 4; i++) cin >> P[i].X >> P[i].Y;
    for (int i = 0; i < 4; i++) cin >> M[i].X >> M[i].Y;

    function<pdd(pdd)> f = [&](pdd p){
        long double u = (p - P[0]) * (P[1] - P[0]) / norm2(P[1] - P[0]);
        long double v = (p - P[0]) * (P[3] - P[0]) / norm2(P[3] - P[0]);

        return M[0] + u * (M[1] - M[0]) + v * (M[3] - M[0]);
    };

    function<pdd(pdd)> g = [&](pdd p){
        long double u = (p - M[0]) * (M[1] - M[0]) / norm2(M[1] - M[0]);
        long double v = (p - M[0]) * (M[3] - M[0]) / norm2(M[3] - M[0]);

        if (u > -eps && u < 1 + eps && v > -eps && v < 1 + eps)
            return P[0] + u * (P[1] - P[0]) + v * (P[3] - P[0]);
        else
            return p;
    };

    long double ans = 1e11;

    pdd A, B;
    cin >> A.X >> A.Y >> B.X >> B.Y;

    long double k;
    int n;
    cin >> k >> n;

    vector<pdd> tela(2 * n + 1), telb(2 * n + 1);
    tela[n] = A, telb[n] = B;

    for (int i = 1; i <= n; i++){
        tela[n + i] = f(tela[n + i - 1]);
        telb[n + i] = f(telb[n + i - 1]);
    }

    for (int i = -1; i >= -n; i--){
        tela[n + i] = g(tela[n + i + 1]);
        telb[n + i] = g(telb[n + i + 1]);
    }

    for (int i = -n; i <= n; i++){
        for (int j = -n; j <= n; j++){
            if (abs(i) + abs(j) <= n){
                long double tmp = k * (abs(i) + abs(j)) + dist(tela[n + i], telb[n + j]);
                chmin(ans, tmp);
            }
        }
    }

    cout << ans << '\n';
}
int main() {
    IOS;
    cout << fixed << setprecision(30);
    cerr << fixed << setprecision(30);
    int T; cin >> T;
    while (T--) {
        solve();
    }
    return 0;
}