#include <cmath>
#include <iomanip>
#include <iostream>
#include <algorithm>

using namespace std;

typedef long double ld;

const int maxn = 250;
const ld eps = 1e-10;


struct point {
  ld x,y;
  point (ld x_ = 0,ld y_ = 0){
      x = x_;
      y = y_;
  }
  point operator-(point a){
      return point(x-a.x,y-a.y);
  }
  point operator+(point a){
      return point(x+a.x,y+a.y);
  }
};

point operator*(ld k,point x){
    return point(x.x*k,x.y*k);
}

point u[maxn],v[maxn];
point r1[5],r2[5];

inline ld sqr(ld x){
    return x *x;
}

inline ld dist(point a,point b){
    return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));
}

inline ld det(point u,point v){
    return u.x * v.y - u.y * v.x;
}

point solve(point u,point v,point x){
    ld d = det(u,v);
    return point(det(x,v) / d, det(u,x) / d);
}

point f(point x){
    // Solve linear system s * u + t * v == x
    point p = solve(r1[2] - r1[1],r1[4] - r1[1], x - r1[1]);
    return r2[1] + p.x * (r2[2] - r2[1]) + p.y * (r2[4] - r2[1]);
}

bool in_map(point x){
    point p = solve(r2[2] - r2[1],r2[4] - r2[1], x - r2[1]);
    return (p.x >= -eps && p.x <= 1 + eps && p.y >= -eps && p.y <= 1 + eps);
}

point f_inv(point x){
  point p = solve(r2[2] - r2[1],r2[4] - r2[1], x - r2[1]);
  return r1[1] + p.x * (r1[2] - r1[1]) + p.y * (r1[4] - r1[1]);
}

void solve(){
    for (int i = 1;i <= 4;i++){
        cin >> r1[i].x >> r1[i].y;
    }
    for (int i = 1;i <= 4;i++){
        cin >> r2[i].x >> r2[i].y;
    }
    point x,y;
    cin >> x.x >> x.y >> y.x >> y.y;
    ld k;
    int n;
    cin >> k >> n;
    u[n] = x;
    v[n] = y;
    for (int i = 1;i <= n;i++){
        u[n+i] = f(u[n+i-1]);
        v[n+i] = f(v[n+i-1]);
      //  printf("u[%d] = (%.3Lf,%.3Lf)\n",i, u[n+i].x,u[n+i].y);
      //  printf("v[%d] = (%.3Lf,%.3Lf)\n",i, v[n+i].x,v[n+i].y);

    }
    int last_u, last_v;
    last_u = n;
    last_v = n;
    for (int i = 0;i < n;i++){
        if (!in_map(u[n-i])){
            break;
        }
        u[n-i-1] = f_inv(u[n-i]);
        last_u--;
    }
    for (int i = 0;i < n;i++){
        if (!in_map(v[n-i])){
            break;
        }
        v[n-i-1] = f_inv(v[n-i]);
        last_v--;
    }
    ld opt = dist(x,y);
    for (int i = last_u;i <= 2*n;i++){
        for (int j = last_v;j <= 2*n;j++){
            if (abs(i-n) + abs(j-n) > n) continue;
            opt = min(opt, k * (abs(i-n) + abs(j-n)) + dist(u[i],v[j]));
        }
    }
    cout << opt << endl;
}

int main(){
    int t;
    cin >> t;
    cout << fixed << setprecision(11);
    while (t--){
        solve();
    }
}