/*
Mohit Dhattarwal
*/
#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;

#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define foreach(it, v) for(auto it=(v).begin(); it != (v).end(); ++it)
#define gcd(a,b) __gcd(a,b)

#define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define filewr() freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);

#define tr(...) cout<<__FUNCTION__<<' '<<__LINE__<<" = ";trace(#__VA_ARGS__, __VA_ARGS__)

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<string,ll> psl;
typedef pair<ll,string> pls;

template<typename S, typename T>
ostream& operator<<(ostream& out,pair<S,T> const& p){out<<'('<<p.fi<<", "<<p.se<<')';return out;}

template<typename T>
ostream& operator<<(ostream& out,vector<T> const& v){
int l=v.size();for(int i=0;i<l-1;i++)out<<v[i]<<' ';if(l>0)out<<v[l-1];return out;}

template<typename T>
void trace(const char* name, T&& arg1){cout<<name<<" : "<<arg1<<endl;}

template<typename T, typename... Args>
void trace(const char* names, T&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');cout.write(names, comma-names)<<" : "<<arg1<<" | ";trace(comma+1,args...);}

const ld PI = 3.1415926535897932384626433832795;

typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> indexed_set;

set<pll> s;

bool isright(ll i, ll j)
{
	if(s.find({i,j+1})!=s.end())
	{
		return true;
	}
	return false;
}
bool isleft(ll i, ll j)
{
	if(s.find({i,j-1})!=s.end())
	{
		return true;
	}
	return false;
}
bool isup(ll i, ll j)
{
	if(s.find({i-1,j})!=s.end())
	{
		return true;
	}
	return false;
}
bool isdown(ll i, ll j)
{
	if(s.find({i+1,j})!=s.end())
	{
		return true;
	}
	return false;
}

void solve()
{
	ll n,m,k;
	cin>>n>>m>>k;
	ll temp[n+1][m+1];
	for(ll i =0; i<=m; i++)
	{
		for(ll j=0; j<=n; j++)
		{
			temp[i][j] = 0;
		}
	}

	ll count = 1;
	vector<ll> a[k+1];
	for(ll i =1; i<=m & count<k; i++)
	{
		for(ll j =1; j<=n; j++)
		{
			if(temp[i][j]==0 && i+1<=m)
			{
				a[count].pb(2);
				a[count].pb(i);
				a[count].pb(i+1);
				a[count].pb(j);
				a[count].pb(j);
				//count++;
				temp[i][j] = count;
				temp[i+1][j] = count;
				count++;
				if(count==k)
				{
					break;
				}
			}
		}
	}

	for(ll i =1; i<=m; i++)
	{
		for(ll j =1; j<=n; j++)
		{
			if(temp[i][j] == 0)
			{
				s.insert({i,j});
			}
		}
	}

	while(count<k)
	{
		while(!s.empty())
		{
			pll t = *s.begin();
			s.erase(s.begin());
			pll now = *s.begin();
			s.erase(s.begin());
			temp[t.fi][t.se] = count;
			temp[now.fi][now.se] = count;
			a[count].pb(2);
			a[count].pb(t.fi);
			a[count].pb(now.fi);
			a[count].pb(t.se);
			a[count].pb(now.se);
			count++;
			if(count==k)
			{
				break;
			}
		}
	}
	for(ll i =1; i<k; i++)
	{
		for(ll j=0; j<a[i].size(); j++)
		{
			cout<<a[i][j]<<" ";
		}
		cout<<'\n';
	}
	//tr(1);
	if(s.size()>0)
	{
		cout<<s.size()<<" ";
		vector<ll> x;
		vector<ll> y;
		ll start = 0;
		pll prev = {0,0};
		pll z = prev;
		pll t;
		while(!s.empty())
		{
			if(prev==z)
			{
				t = *s.begin();
			}
			else
			{
				t = prev;
			}
			x.pb(t.fi);
			y.pb(t.se);
			temp[t.fi][t.se] = count;
			//temp[t.se] = count;
			s.erase(t);
			if(isright(t.fi,t.se))
			{
				prev = {t.fi,t.se+1};
			}
			else if(isleft(t.fi,t.se))
			{
				prev = {t.fi,t.se-1};
			}
			else if(isdown(t.fi,t.se))
			{
				prev = {t.fi+1,t.se};
			}
		}
		for(ll i =0; i<x.size(); i++)
		{
			cout<<x[i]<<" ";
		}
		for(ll j =0; j<y.size(); j++)
		{
			cout<<y[j]<<" ";
		}
		cout<<'\n';
	}

}

int main(){
	fastio();
	ll t;
	t=1;
	while(t--)
	{
		solve();
	}
	return 0;
}


/*
Mohit Dhattarwal
*/
#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;

#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define foreach(it, v) for(auto it=(v).begin(); it != (v).end(); ++it)
#define gcd(a,b) __gcd(a,b)

#define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define filewr() freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);

#define tr(...) cout<<__FUNCTION__<<' '<<__LINE__<<" = ";trace(#__VA_ARGS__, __VA_ARGS__)

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<string,ll> psl;
typedef pair<ll,string> pls;

template<typename S, typename T>
ostream& operator<<(ostream& out,pair<S,T> const& p){out<<'('<<p.fi<<", "<<p.se<<')';return out;}

template<typename T>
ostream& operator<<(ostream& out,vector<T> const& v){
int l=v.size();for(int i=0;i<l-1;i++)out<<v[i]<<' ';if(l>0)out<<v[l-1];return out;}

template<typename T>
void trace(const char* name, T&& arg1){cout<<name<<" : "<<arg1<<endl;}

template<typename T, typename... Args>
void trace(const char* names, T&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');cout.write(names, comma-names)<<" : "<<arg1<<" | ";trace(comma+1,args...);}

const ld PI = 3.1415926535897932384626433832795;

typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> indexed_set;

set<pll> s;

bool isright(ll i, ll j)
{
	if(s.find({i,j+1})!=s.end())
	{
		return true;
	}
	return false;
}
bool isleft(ll i, ll j)
{
	if(s.find({i,j-1})!=s.end())
	{
		return true;
	}
	return false;
}
bool isup(ll i, ll j)
{
	if(s.find({i-1,j})!=s.end())
	{
		return true;
	}
	return false;
}
bool isdown(ll i, ll j)
{
	if(s.find({i+1,j})!=s.end())
	{
		return true;
	}
	return false;
}

void solve()
{
	ll n,m,k;
	cin>>n>>m>>k;
	ll temp[n+1][m+1];
	for(ll i =0; i<=m; i++)
	{
		for(ll j=0; j<=n; j++)
		{
			temp[i][j] = 0;
		}
	}

	ll count = 1;
	vector<ll> a[k+1];
	for(ll i =1; i<=m & count<k; i++)
	{
		for(ll j =1; j<=n; j++)
		{
			if(temp[i][j]==0 && i+1<=m)
			{
				a[count].pb(2);
				a[count].pb(i);
				a[count].pb(j);
				a[count].pb(i+1);
				a[count].pb(j);
				//count++;
				temp[i][j] = count;
				temp[i+1][j] = count;
				count++;
				if(count==k)
				{
					break;
				}
			}
		}
	}

	for(ll i =1; i<=m; i++)
	{
		for(ll j =1; j<=n; j++)
		{
			if(temp[i][j] == 0)
			{
				s.insert({i,j});
			}
		}
	}

	while(count<k)
	{
		while(!s.empty())
		{
			pll t = *s.begin();
			s.erase(s.begin());
			pll now = *s.begin();
			s.erase(s.begin());
			temp[t.fi][t.se] = count;
			temp[now.fi][now.se] = count;
			a[count].pb(2);
			a[count].pb(t.fi);
			a[count].pb(t.se);
			a[count].pb(now.fi);
			a[count].pb(now.se);
			count++;
			if(count==k)
			{
				break;
			}
		}
	}
	for(ll i =1; i<k; i++)
	{
		for(ll j=0; j<a[i].size(); j++)
		{
			cout<<a[i][j]<<" ";
		}
		cout<<'\n';
	}
	//tr(1);
	if(s.size()>0)
	{
		cout<<s.size()<<" ";
		ll start = 0;
		pll prev = {0,0};
		pll z = prev;
		pll t;
		while(!s.empty())
		{
			if(prev==z)
			{
				t = *s.begin();
			}
			else
			{
				t = prev;
			}
			cout<<t.fi<<" "<<t.se<<" ";
			//temp[t.se] = count;
			s.erase(t);
			if(isright(t.fi,t.se))
			{
				prev = {t.fi,t.se+1};
			}
			else if(isleft(t.fi,t.se))
			{
				prev = {t.fi,t.se-1};
			}
			else if(isdown(t.fi,t.se))
			{
				prev = {t.fi+1,t.se};
			}
		}
		cout<<'\n';
	}

}

int main(){
	fastio();
	ll t;
	t=1;
	while(t--)
	{
		solve();
	}
	return 0;
}


/*
Mohit Dhattarwal
*/
#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;

#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define foreach(it, v) for(auto it=(v).begin(); it != (v).end(); ++it)
#define gcd(a,b) __gcd(a,b)

#define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define filewr() freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);

#define tr(...) cout<<__FUNCTION__<<' '<<__LINE__<<" = ";trace(#__VA_ARGS__, __VA_ARGS__)

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<string,ll> psl;
typedef pair<ll,string> pls;

template<typename S, typename T>
ostream& operator<<(ostream& out,pair<S,T> const& p){out<<'('<<p.fi<<", "<<p.se<<')';return out;}

template<typename T>
ostream& operator<<(ostream& out,vector<T> const& v){
int l=v.size();for(int i=0;i<l-1;i++)out<<v[i]<<' ';if(l>0)out<<v[l-1];return out;}

template<typename T>
void trace(const char* name, T&& arg1){cout<<name<<" : "<<arg1<<endl;}

template<typename T, typename... Args>
void trace(const char* names, T&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');cout.write(names, comma-names)<<" : "<<arg1<<" | ";trace(comma+1,args...);}

const ld PI = 3.1415926535897932384626433832795;

typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> indexed_set;

void solve()
{
	ll n,m,k;
	cin>>n>>m>>k;
	ll a[m+1][n+1];
	set<pll> s;

	for(ll i =1; i<=n; i++)
	{
		for(ll j=1; j<=m; j++)
		{
			a[i][j] = 0;
			s.insert({i,j});
		}
	}

	ll count = 1;

	for(ll i=1; i<=n & count<k; i++)
	{
		for(ll j =1; j<=m; j++)
		{
			if(a[i][j]==0 && i!=m)
			{
				a[i][j] = count;
				a[i+1][j] = count;
				count++;
				s.erase({i,j});s.erase({i+1,j});
				cout<<2<<" "<<i<<" "<<j<<" "<<i+1<<" "<<j<<'\n';
				if(count==k)
				{
					break;
				}
			}
		}
	}

	if(count!=k)
	{
		for(ll i=1; i<=m; i++)
		{
			if(a[n][i]==0 && i!=m)
			{
				s.erase({n,i});s.erase({n,i+1});
				cout<<2<<" "<<n<<" "<<i<<" "<<n<<" "<<i+1<<'\n';
				a[n][i] = count;
				a[n][i+1] = count;
				count++;
				if(count==k)
				{
					break;
				}
			}
		}
	}
	cout<<s.size()<<" ";
	pll t = *s.begin();
	ll num = s.size();
	while(num>0)
	{
		cout<<t.fi<<" "<<t.se<<" ";
		a[t.fi][t.se] = count;
		s.erase(t);
		if(s.find({t.fi,t.se+1})!=s.end())
		{
			t = {t.fi,t.se+1};
		}
		else if(s.find({t.fi, t.se-1})!=s.end())
		{
			t = {t.fi, t.se-1};
		}
		else if(s.find({t.fi+1,t.se})!=s.end())
		{
			t = {t.fi+1, t.se};
		}
		num--;

	}
	cout<<'\n';
}

int main(){
	fastio();
	ll t;
	t=1;
	while(t--)
	{
		solve();
	}
	return 0;
}


/*
Mohit Dhattarwal
*/
#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;

#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define foreach(it, v) for(auto it=(v).begin(); it != (v).end(); ++it)
#define gcd(a,b) __gcd(a,b)

#define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define filewr() freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);

#define tr(...) cout<<__FUNCTION__<<' '<<__LINE__<<" = ";trace(#__VA_ARGS__, __VA_ARGS__)

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<string,ll> psl;
typedef pair<ll,string> pls;

template<typename S, typename T>
ostream& operator<<(ostream& out,pair<S,T> const& p){out<<'('<<p.fi<<", "<<p.se<<')';return out;}

template<typename T>
ostream& operator<<(ostream& out,vector<T> const& v){
int l=v.size();for(int i=0;i<l-1;i++)out<<v[i]<<' ';if(l>0)out<<v[l-1];return out;}

template<typename T>
void trace(const char* name, T&& arg1){cout<<name<<" : "<<arg1<<endl;}

template<typename T, typename... Args>
void trace(const char* names, T&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');cout.write(names, comma-names)<<" : "<<arg1<<" | ";trace(comma+1,args...);}

const ld PI = 3.1415926535897932384626433832795;

typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> indexed_set;

void solve()
{
	ll n,m,k;
	cin>>n>>m>>k;
	ll num = (n*m)/k;
	ll count = (n*k)%k;

	set<pll> s;

	for(ll i =1; i<=n; i++)
	{
		for(ll j=1; j<=m; j++)
		{
			s.insert({i,j});
		}
	}
	//tr(num,count);
	pll t = *s.begin();

	for(ll i =0; i<k; i++)
	{
		if(count>0)
		{
			cout<<num+1<<" ";
			for(ll i =0; i<num+1; i++)
			{

				cout<<t.fi<<" "<<t.se<<" ";
				s.erase(t);
				if(s.find({t.fi,t.se+1})!=s.end())
				{
					t = {t.fi,t.se+1};
				}
				else if(s.find({t.fi,t.se-1})!=s.end())
				{
					t = {t.fi,t.se-1};
				}
				else if(s.find({t.fi+1,t.se})!=s.end())
				{
					t = {t.fi+1,t.se};
				}
			}
			cout<<'\n';
			count--;
		}
		else
		{
			cout<<num<<" ";
			for(ll i =0; i<num; i++)
			{
				//tr(1);

				cout<<t.fi<<" "<<t.se<<" ";
				s.erase(t);
				if(s.find({t.fi,t.se+1})!=s.end())
				{
					t = {t.fi,t.se+1};
				}
				else if(s.find({t.fi,t.se-1})!=s.end())
				{
					t = {t.fi,t.se-1};
				}
				else if(s.find({t.fi+1,t.se})!=s.end())
				{
					t = {t.fi+1,t.se};
				}
			}
			cout<<'\n';
		}
	}

}

int main(){
	fastio();
	ll t;
	t=1;
	while(t--)
	{
		solve();
	}
	return 0;
}


/*
Mohit Dhattarwal
*/
#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;

#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define foreach(it, v) for(auto it=(v).begin(); it != (v).end(); ++it)
#define gcd(a,b) __gcd(a,b)

#define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define filewr() freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);

#define tr(...) cout<<__FUNCTION__<<' '<<__LINE__<<" = ";trace(#__VA_ARGS__, __VA_ARGS__)

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<string,ll> psl;
typedef pair<ll,string> pls;

template<typename S, typename T>
ostream& operator<<(ostream& out,pair<S,T> const& p){out<<'('<<p.fi<<", "<<p.se<<')';return out;}

template<typename T>
ostream& operator<<(ostream& out,vector<T> const& v){
int l=v.size();for(int i=0;i<l-1;i++)out<<v[i]<<' ';if(l>0)out<<v[l-1];return out;}

template<typename T>
void trace(const char* name, T&& arg1){cout<<name<<" : "<<arg1<<endl;}

template<typename T, typename... Args>
void trace(const char* names, T&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');cout.write(names, comma-names)<<" : "<<arg1<<" | ";trace(comma+1,args...);}

const ld PI = 3.1415926535897932384626433832795;

typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> indexed_set;

void solve()
{
	ll n,m,k;
	cin>>n>>m>>k;
	ll a[m+1][n+1];
	set<pll> s;

	for(ll i =1; i<=n; i++)
	{
		for(ll j=1; j<=m; j++)
		{
			a[i][j] = 0;
			s.insert({i,j});
		}
	}

	ll count = 1;

	for(ll i=1; i<=n & count<k; i++)
	{
		for(ll j =1; j<=m; j++)
		{
			if(a[i][j]==0 && i!=m)
			{
				a[i][j] = count;
				a[i+1][j] = count;
				count++;
				s.erase({i,j});s.erase({i+1,j});
				cout<<2<<" "<<i<<" "<<j<<" "<<i+1<<" "<<j<<'\n';
				if(count==k)
				{
					break;
				}
			}
		}
	}

	if(count!=k)
	{
		for(ll i=1; i<=m; i++)
		{
			if(a[n][i]==0 && i!=m)
			{
				s.erase({n,i});s.erase({n,i+1});
				cout<<2<<" "<<n<<" "<<i<<" "<<n<<" "<<i+1<<'\n';
				a[n][i] = count;
				a[n][i+1] = count;
				count++;
				if(count==k)
				{
					break;
				}
			}
		}
	}
	cout<<s.size()<<" ";
	pll t = *s.begin();
	ll num = s.size();
	while(!s.empty())
	{
		if(s.find(t)!=s.end())
		{
			cout<<t.fi<<" "<<t.se<<" ";
			a[t.fi][t.se] = count;
			s.erase(t);
			if(s.find({t.fi,t.se+1})!=s.end())
			{
				t = {t.fi,t.se+1};
			}
			else if(s.find({t.fi, t.se-1})!=s.end())
			{
				t = {t.fi, t.se-1};
			}
			else if(s.find({t.fi+1,t.se})!=s.end())
			{
				t = {t.fi+1, t.se};
			}
		}
		else
		{
			break;
		}

	}
	cout<<'\n';
}

int main(){
	fastio();
	ll t;
	t=1;
	while(t--)
	{
		solve();
	}
	return 0;
}


#include <stdio.h>
#include <math.h>

double eps = 1e-14;

double X, Y;
int VMax, T;
int Vx, Vy, Wx, Wy;

double length( double x, double y ) {
    return sqrtl( x * x + y * y );
}

double test( double time ) {

    double x;
    double y;

    if ( time <= T ) {
        x = time * Vx;
        y = time * Vy;
    } else {
        x = T * Vx + (time - T) * Wx;
        y = T * Vy + (time - T) * Wy;
    }

    return length( X - x, Y - y ) > 1.0 * VMax * time;
}

double search_time( double time ) {

    double ls = 0;
    double ld = time;

    while ( ld - ls >= eps ) {
        double mid = ls + (ld - ls) / 2;

        if ( test(mid) )
            ls = mid;
        else ld = mid;

    }

    return ld;
}

int main() {

    int x, y;

    freopen("in", "r", stdin); freopen("out", "w", stdout);

    scanf("%d%d%lf%lf"
          "%d%d"
          "%d%d%d%d", &x, &y, &X, &Y
                    , &VMax, &T
                    , &Vx, &Vy, &Wx, &Wy);
    X -= x;
    Y -= y;

    printf("%.12lf\n", search_time(1000000.0));

    return 0;
}


#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define f first
#define s second
#define PI 3.14159265359
#define CS ios_base::sync_with_stdio(0);cin.tie(0);
using namespace std;
const ll inf = 1e18;
double x1,x2,yh,y2,vmx,t,vx,vy,wx,wy,sx,sy,X,Y;
bool check(double T){
    double nt=max(T-t,(double)0),ex=wx*nt,ey=wy*nt;
    sx=vx*min(t,T),sy=vy*min(T,t),X=x2-x1,Y=y2-yh;
    double xvec=sx+ex,yvec=sy+ey;
    double newx=X-xvec,newy=Y-yvec;
    double s=sqrt(newx*newx + newy*newy),v=s/T;
    //cout<<X<<" "<<Y<<" "<<xvec<<" "<<yvec<<" "<<newx<<" "<<newy<<' '<<s<<" "<<v<<endl;
    if(v<=vmx)return 1;
    return 0;
}
int main(){
    CS;
    cin>>x1>>yh>>x2>>y2>>vmx>>t>>vx>>vy>>wx>>wy;
    double be=0,en=1e9,mid=(be+en)/2,ans=0,cnt=200;
    while(be<en&&cnt){
        cnt--;
        mid=(be+en)/2;
        if(check(mid)){ans=mid;en=mid+0.001;}
        else be=mid-0.001;
    }
    cout<<setprecision(20)<<fixed<<ans<<endl;
    return 0;
}


#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define f first
#define s second
#define PI 3.14159265359
#define CS ios_base::sync_with_stdio(0);cin.tie(0);
using namespace std;
const ll inf = 1e18;
double x1,x2,yh,y2,vmx,t,vx,vy,wx,wy,sx,sy,X,Y;
bool check(double T){
    double nt=max(T-t,(double)0),ex=wx*nt,ey=wy*nt;
    sx=vx*min(t,T),sy=vy*min(T,t),X=x2-x1,Y=y2-yh;
    double xvec=sx+ex,yvec=sy+ey;
    double newx=X-xvec,newy=Y-yvec;
    double s=sqrt(newx*newx + newy*newy),v=s/T;
    //cout<<X<<" "<<Y<<" "<<xvec<<" "<<yvec<<" "<<newx<<" "<<newy<<' '<<s<<" "<<v<<endl;
    if(v<=vmx)return 1;
    return 0;
}
int main(){
    CS;
    cin>>x1>>yh>>x2>>y2>>vmx>>t>>vx>>vy>>wx>>wy;
    double be=0,en=1e9,mid=(be+en)/2,ans=0,cnt=200;
    while(be<en&&cnt){
        cnt--;
        mid=(be+en)/2;
        if(check(mid)){ans=mid;en=mid;}
        else be=mid;
    }
    cout<<setprecision(20)<<fixed<<ans<<endl;
    return 0;
}


// Copyright (C) 2015 Sayutin Dmitry.
//
// This Program is free  software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
//
// You should have received a copy of the GNU General Public License
// If not, see <http://www.gnu.org/licenses/>.

#include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <algorithm>
#include <utility>
#include <stdint.h>
#include <assert.h>

using std::cin;
using std::cout;
using std::cerr;
using std::endl;

using std::vector;
using std::string;

using std::pair;
using std::make_pair;

using std::min;
using std::max;
using std::abs;

template <typename T>
inline T input()
{
	T ans;
	cin >> ans;
	return ans;
}

#ifdef __CDKROT_LOCAL
#define debug_print_single(x) {debug_print_seq(x); debug_print_seq_end();}
#define debug_print_seq(x)    {cerr << #x << " = " << x << ", ";}
#define debug_print_seq_end() {endl(cerr);}
#define debug_print_text(s)   {cerr << s << endl;}
#else
#define debug_print_single(x) {}
#define debug_print_seq(x)    {}
#define debug_print_seq_end() {}
#define debug_print_text(s)   {}
#endif

template <typename FloatT>
struct vec2
{
	public:
		vec2() {}

		template <typename OtherT>
		vec2(vec2<OtherT> other): x(other.x), y(other.y) {}

		vec2(FloatT x, FloatT y): x(x), y(y) {}

		vec2<FloatT> operator-(vec2<FloatT> other)
		{
			return vec2<FloatT>(x - other.x, y - other.y);
		}
		vec2<FloatT> operator+(vec2<FloatT> other)
		{
			return vec2<FloatT>(x + other.x, y + other.y);
		}
		vec2<FloatT> operator*(FloatT num)
		{
			return vec2<FloatT>(num * x, num * y);
		}

		FloatT len()
		{
			return std::sqrt(x * x + y * y);
		}

		FloatT x;
		FloatT y;
};

const uint32_t num_iterations = 10000;

int main()
{
	vec2<int32_t> src;
	vec2<int32_t> dest;
	int32_t v, t;
	vec2<int32_t> wind_before;
	vec2<int32_t> wind_after;

	cin >> src.x >> src.y >> dest.x >> dest.y;
	cin >> v >> t;
	cin >> wind_before.x >> wind_before.y >> wind_after.x >> wind_after.y;

	if ((vec2<double>(src - dest) + vec2<double>(wind_before) * t).len() <= v * t)
	{
		float left = 0; // probably can't
		float right = t; // can.
		for (uint32_t i = 0; i != num_iterations; ++i)
		{
			float mid = left + (right - left) / 2;
			if ((vec2<double>(src - dest) + vec2<double>(wind_before) * mid).len() <= v * mid)
				right = mid;
			else
				left = mid;
		}

		cout.precision(20);
		cout << std::fixed << right << endl;
	}
	else
	{
		vec2<double> new_src = vec2<double>(new_src) + vec2<double>(wind_before) * t;
		float left = 0; // can't
		float right = 100500; // can.
		for (uint32_t i = 0; i != num_iterations; ++i)
		{
			float mid = left + (right - left) / 2;
			if ((new_src - vec2<double>(dest) + vec2<double>(wind_after) * mid).len() <= v * (t + mid))
				right = mid;
			else
				left = mid;
		}
		cout.precision(20);
		cout << std::fixed << t + right << endl;
	}

	return 0;
}


// Copyright (C) 2015 Sayutin Dmitry.
//
// This Program is free  software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
//
// You should have received a copy of the GNU General Public License
// If not, see <http://www.gnu.org/licenses/>.

#include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <algorithm>
#include <utility>
#include <stdint.h>
#include <assert.h>

using std::cin;
using std::cout;
using std::cerr;
using std::endl;

using std::vector;
using std::string;

using std::pair;
using std::make_pair;

using std::min;
using std::max;
using std::abs;

template <typename T>
inline T input()
{
	T ans;
	cin >> ans;
	return ans;
}

#ifdef __CDKROT_LOCAL
#define debug_print_single(x) {debug_print_seq(x); debug_print_seq_end();}
#define debug_print_seq(x)    {cerr << #x << " = " << x << ", ";}
#define debug_print_seq_end() {endl(cerr);}
#define debug_print_text(s)   {cerr << s << endl;}
#else
#define debug_print_single(x) {}
#define debug_print_seq(x)    {}
#define debug_print_seq_end() {}
#define debug_print_text(s)   {}
#endif

template <typename FloatT>
struct vec2
{
	public:
		vec2() {}

		template <typename OtherT>
		vec2(vec2<OtherT> other): x(other.x), y(other.y) {}

		vec2(FloatT x, FloatT y): x(x), y(y) {}

		vec2<FloatT> operator-(vec2<FloatT> other)
		{
			return vec2<FloatT>(x - other.x, y - other.y);
		}
		vec2<FloatT> operator+(vec2<FloatT> other)
		{
			return vec2<FloatT>(x + other.x, y + other.y);
		}
		vec2<FloatT> operator*(FloatT num)
		{
			return vec2<FloatT>(num * x, num * y);
		}

		FloatT len()
		{
			return std::sqrt(x * x + y * y);
		}

		FloatT x;
		FloatT y;
};

const uint32_t num_iterations = 10000;

int main()
{
	vec2<int32_t> src;
	vec2<int32_t> dest;
	int32_t v, t;
	vec2<int32_t> wind_before;
	vec2<int32_t> wind_after;

	cin >> src.x >> src.y >> dest.x >> dest.y;
	cin >> v >> t;
	cin >> wind_before.x >> wind_before.y >> wind_after.x >> wind_after.y;

	if ((vec2<double>(src - dest) + vec2<double>(wind_before) * t).len() <= v * t)
	{
		float left = 0; // probably can't
		float right = t; // can.
		for (uint32_t i = 0; i != num_iterations; ++i)
		{
			float mid = left + (right - left) / 2;
			if ((vec2<double>(src - dest) + vec2<double>(wind_before) * mid).len() <= v * mid)
				right = mid;
			else
				left = mid;
		}

		cout.precision(20);
		cout << std::fixed << right << endl;
	}
	else
	{
		//?? vec2<double> new_src = vec2<double>(new_src);
		vec2<double> new_src = vec2<double>(src) + vec2<double>(wind_before) * t;
		float left = 0; // can't
		float right = 100500; // can.
		for (uint32_t i = 0; i != num_iterations; ++i)
		{
			float mid = left + (right - left) / 2;
			if ((new_src - vec2<double>(dest) + vec2<double>(wind_after) * mid).len() <= v * (t + mid))
				right = mid;
			else
				left = mid;
		}
		cout.precision(20);
		cout << std::fixed << t + right << endl;
	}

	return 0;
}


// Copyright (C) 2015 Sayutin Dmitry.
//
// This Program is free  software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
//
// You should have received a copy of the GNU General Public License
// If not, see <http://www.gnu.org/licenses/>.

#include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <algorithm>
#include <utility>
#include <stdint.h>
#include <assert.h>

using std::cin;
using std::cout;
using std::cerr;
using std::endl;

using std::vector;
using std::string;

using std::pair;
using std::make_pair;

using std::min;
using std::max;
using std::abs;

template <typename T>
inline T input()
{
	T ans;
	cin >> ans;
	return ans;
}

#ifdef __CDKROT_LOCAL
#define debug_print_single(x) {debug_print_seq(x); debug_print_seq_end();}
#define debug_print_seq(x)    {cerr << #x << " = " << x << ", ";}
#define debug_print_seq_end() {endl(cerr);}
#define debug_print_text(s)   {cerr << s << endl;}
#else
#define debug_print_single(x) {}
#define debug_print_seq(x)    {}
#define debug_print_seq_end() {}
#define debug_print_text(s)   {}
#endif

template <typename FloatT>
struct vec2
{
	public:
		vec2() {}

		template <typename OtherT>
		vec2(vec2<OtherT> other): x(other.x), y(other.y) {}

		vec2(FloatT x, FloatT y): x(x), y(y) {}

		vec2<FloatT> operator-(vec2<FloatT> other)
		{
			return vec2<FloatT>(x - other.x, y - other.y);
		}
		vec2<FloatT> operator+(vec2<FloatT> other)
		{
			return vec2<FloatT>(x + other.x, y + other.y);
		}
		vec2<FloatT> operator*(FloatT num)
		{
			return vec2<FloatT>(num * x, num * y);
		}

		FloatT len()
		{
			return std::sqrt(x * x + y * y);
		}

		FloatT x;
		FloatT y;
};

const uint32_t num_iterations = 100000;
#define double long double

int main()
{
	vec2<int32_t> src;
	vec2<int32_t> dest;
	int32_t v, t;
	vec2<int32_t> wind_before;
	vec2<int32_t> wind_after;

	cin >> src.x >> src.y >> dest.x >> dest.y;
	cin >> v >> t;
	cin >> wind_before.x >> wind_before.y >> wind_after.x >> wind_after.y;

	if ((vec2<double>(src - dest) + vec2<double>(wind_before) * t).len() <= v * t)
	{
		float left = 0; // probably can't
		float right = t; // can.
		for (uint32_t i = 0; i != num_iterations; ++i)
		{
			float mid = left + (right - left) / 2;
			if ((vec2<double>(src - dest) + vec2<double>(wind_before) * mid).len() <= v * mid)
				right = mid;
			else
				left = mid;
		}

		cout.precision(20);
		cout << std::fixed << right << endl;
	}
	else
	{
		//?? vec2<double> new_src = vec2<double>(new_src);
		vec2<double> new_src = vec2<double>(src) + vec2<double>(wind_before) * t;
		float left = 0; // can't
		float right = 10000000; // can.
		for (uint32_t i = 0; i != num_iterations; ++i)
		{
			float mid = left + (right - left) / 2;
			if ((new_src - vec2<double>(dest) + vec2<double>(wind_after) * mid).len() <= v * (t + mid))
				right = mid;
			else
				left = mid;
		}
		cout.precision(20);
		cout << std::fixed << t + right << endl;
	}

	return 0;
}


// Copyright (C) 2015 Sayutin Dmitry.
//
// This Program is free  software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
//
// You should have received a copy of the GNU General Public License
// If not, see <http://www.gnu.org/licenses/>.

#include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <algorithm>
#include <utility>
#include <stdint.h>
#include <assert.h>

using std::cin;
using std::cout;
using std::cerr;
using std::endl;

using std::vector;
using std::string;

using std::pair;
using std::make_pair;

using std::min;
using std::max;
using std::abs;

template <typename T>
inline T input()
{
	T ans;
	cin >> ans;
	return ans;
}

#ifdef __CDKROT_LOCAL
#define debug_print_single(x) {debug_print_seq(x); debug_print_seq_end();}
#define debug_print_seq(x)    {cerr << #x << " = " << x << ", ";}
#define debug_print_seq_end() {endl(cerr);}
#define debug_print_text(s)   {cerr << s << endl;}
#else
#define debug_print_single(x) {}
#define debug_print_seq(x)    {}
#define debug_print_seq_end() {}
#define debug_print_text(s)   {}
#endif

template <typename FloatT>
struct vec2
{
	public:
		vec2() {}

		template <typename OtherT>
		vec2(vec2<OtherT> other): x(other.x), y(other.y) {}

		vec2(FloatT x, FloatT y): x(x), y(y) {}

		vec2<FloatT> operator-(vec2<FloatT> other)
		{
			return vec2<FloatT>(x - other.x, y - other.y);
		}
		vec2<FloatT> operator+(vec2<FloatT> other)
		{
			return vec2<FloatT>(x + other.x, y + other.y);
		}
		vec2<FloatT> operator*(FloatT num)
		{
			return vec2<FloatT>(num * x, num * y);
		}

		FloatT len()
		{
			return std::sqrt(x * x + y * y);
		}

		FloatT x;
		FloatT y;
};

const uint32_t num_iterations = 100000;
#define double long double

int main()
{
	vec2<int32_t> src;
	vec2<int32_t> dest;
	int32_t v, t;
	vec2<int32_t> wind_before;
	vec2<int32_t> wind_after;

	cin >> src.x >> src.y >> dest.x >> dest.y;
	cin >> v >> t;
	cin >> wind_before.x >> wind_before.y >> wind_after.x >> wind_after.y;

	if ((vec2<double>(src - dest) + vec2<double>(wind_before) * t).len() <= v * t)
	{
		float left = 0; // probably can't
		float right = t; // can.
		for (uint32_t i = 0; i != num_iterations; ++i)
		{
			float mid = left + (right - left) / 2;
			if ((vec2<double>(src - dest) + vec2<double>(wind_before) * mid).len() <= v * mid)
				right = mid;
			else
				left = mid;
		}

		cout.precision(20);
		cout << std::fixed << right << endl;
	}
	else
	{
		//?? vec2<double> new_src = vec2<double>(new_src);
		vec2<double> new_src = vec2<double>(src) + vec2<double>(wind_before) * t;
		float left = 0; // can't
		float right = 1005000; // can.
		for (uint32_t i = 0; i != num_iterations; ++i)
		{
			float mid = left + (right - left) / 2;
			if ((new_src - vec2<double>(dest) + vec2<double>(wind_after) * mid).len() <= v * (t + mid))
				right = mid;
			else
				left = mid;
		}
		cout.precision(20);
		cout << std::fixed << t + right << endl;
	}

	return 0;
}


// Copyright (C) 2015 Sayutin Dmitry.
//
// This Program is free  software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
//
// You should have received a copy of the GNU General Public License
// If not, see <http://www.gnu.org/licenses/>.

#include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <algorithm>
#include <utility>
#include <stdint.h>
#include <assert.h>

using std::cin;
using std::cout;
using std::cerr;
using std::endl;

using std::vector;
using std::string;

using std::pair;
using std::make_pair;

using std::min;
using std::max;
using std::abs;

template <typename T>
inline T input()
{
	T ans;
	cin >> ans;
	return ans;
}

#ifdef __CDKROT_LOCAL
#define debug_print_single(x) {debug_print_seq(x); debug_print_seq_end();}
#define debug_print_seq(x)    {cerr << #x << " = " << x << ", ";}
#define debug_print_seq_end() {endl(cerr);}
#define debug_print_text(s)   {cerr << s << endl;}
#else
#define debug_print_single(x) {}
#define debug_print_seq(x)    {}
#define debug_print_seq_end() {}
#define debug_print_text(s)   {}
#endif

template <typename FloatT>
struct vec2
{
	public:
		vec2() {}

		template <typename OtherT>
		vec2(vec2<OtherT> other): x(other.x), y(other.y) {}

		vec2(FloatT x, FloatT y): x(x), y(y) {}

		vec2<FloatT> operator-(vec2<FloatT> other)
		{
			return vec2<FloatT>(x - other.x, y - other.y);
		}
		vec2<FloatT> operator+(vec2<FloatT> other)
		{
			return vec2<FloatT>(x + other.x, y + other.y);
		}
		vec2<FloatT> operator*(FloatT num)
		{
			return vec2<FloatT>(num * x, num * y);
		}

		FloatT len()
		{
			return std::sqrt(x * x + y * y);
		}

		FloatT x;
		FloatT y;
};

const uint32_t num_iterations = 100000;
#define double long double

int main()
{
	vec2<int32_t> src;
	vec2<int32_t> dest;
	int32_t v, t;
	vec2<int32_t> wind_before;
	vec2<int32_t> wind_after;

	cin >> src.x >> src.y >> dest.x >> dest.y;
	cin >> v >> t;
	cin >> wind_before.x >> wind_before.y >> wind_after.x >> wind_after.y;

	if ((vec2<double>(src - dest) + vec2<double>(wind_before) * t).len() <= v * t)
	{
		float left = 0; // probably can't
		float right = t; // can.
		for (uint32_t i = 0; i != num_iterations; ++i)
		{
			float mid = left + (right - left) / 2;
			if ((vec2<double>(src - dest) + vec2<double>(wind_before) * mid).len() <= v * mid)
				right = mid;
			else
				left = mid;
		}

		cout.precision(20);
		cout << std::fixed << right << endl;
	}
	else
	{
		//?? vec2<double> new_src = vec2<double>(new_src);
		vec2<double> new_src = vec2<double>(src) + vec2<double>(wind_before) * t;
		float left = 0; // can't
		float right = 1000000000; // can.
		for (uint32_t i = 0; i != num_iterations; ++i)
		{
			float mid = left + (right - left) / 2;
			if ((new_src - vec2<double>(dest) + vec2<double>(wind_after) * mid).len() <= v * (t + mid))
				right = mid;
			else
				left = mid;
		}
		cout.precision(20);
		cout << std::fixed << t + right << endl;
	}

	return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
#define FOR(i, x, y) for(int i = x; i < y; ++ i)
#define pb push_back
#define mk make_pair

const int P = 1000000007;
const int N = 1123456;
ll l;
int n, m, u;
int a[N], v[N], c[N], f[N];

void upd(int& x, int y) {
	x += y;
	if (x >= P)
		x -= P;
}

int main() {
#ifdef LOCAL
	freopen("in","r",stdin);
#endif
	cin >> n >> l >> m;
	FOR(i,0,n)
		scanf("%d", a + i), v[i] = a[i];
	sort(v, v + n);
	u = unique(v, v + n) - v;
	FOR(i,0,n)
		a[i] = lower_bound(v, v + u, a[i]) - v + 1;
	ll s = l / n;
	int ans = 0;
	int ed = (int) min((ll) m, s + 1);
	FOR(j, 0, ed)
	{
		FOR(i,1,u+1)
			c[i] = 0;
		FOR(i,0,n)
			for (int x = a[i]; x <= u; x += x & -x)
				upd(c[x], f[i]);
		FOR(i,0,n)
		{
			f[i] = j == 0;
			for (int x = a[i]; x > 0; x -= x & -x)
				upd(f[i], c[x]);
			if (j < s)
				ans = (ans + (s - j) % P * f[i]) % P;
			if (ans < 0)
				ans += P;
			if (i < l % n)
				upd(ans, f[i]);
		}
	}
	printf("%d\n", ans);
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
#define FOR(i, x, y) for(int i = x; i < y; ++ i)
#define pb push_back
#define mk make_pair

typedef double R;

struct R2 {
	R x, y;
	R2(R x = 0.0, R y = 0.0) :
			x(x), y(y) {
	}
	R2 operator +(const R2 &A) const {
		return R2(x + A.x, y + A.y);
	}
	R2 operator -(const R2 &A) const {
		return R2(x - A.x, y - A.y);
	}
	R2 operator *(const R &A) const {
		return R2(x * A, y * A);
	}
	R2 operator /(const R &A) const {
		return R2(x / A, y / A);
	}
	R len() const {
		return sqrt(x * x + y * y);
	}
	R read() {
		scanf("%lf%lf", &x, &y);
	}
	void prt() const {
		printf("%lf %lf\n", x, y);
	}
};

const R EPS = 1e-8;
R2 O, A, V, W;
int v;
int t;

R solve(R2 A, R2 V, R r, R extra = 0.0) {
	double l = 0, m;
	while (l + EPS < r) {
		m = (l + r) / 2.0;
//		printf("%lf %lf %d\n", m, (A - V * m).len(), v);
//		(A - V * m).prt();
		if ((A - V * m).len() < v * (m + extra))
			r = m;
		else
			l = m;
	}
	return l;
}

int main() {
#ifdef LOCAL
	freopen("in","r",stdin);
#endif
	O.read();
	A.read();
	A = A - O;
	scanf("%d%d", &v, &t);
	V.read(), W.read();

	R ans = solve(A, V, t);
	if (ans > t - EPS)
		ans = t + solve(A - V * t, W, 1e6, t);
	printf("%.9lf\n", ans);
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
#define FOR(i, x, y) for(int i = x; i < y; ++ i)
#define pb push_back
#define mk make_pair

typedef double R;

struct R2 {
	R x, y;
	R2(R x = 0.0, R y = 0.0) :
			x(x), y(y) {
	}
	R2 operator +(const R2 &A) const {
		return R2(x + A.x, y + A.y);
	}
	R2 operator -(const R2 &A) const {
		return R2(x - A.x, y - A.y);
	}
	R2 operator *(const R &A) const {
		return R2(x * A, y * A);
	}
	R2 operator /(const R &A) const {
		return R2(x / A, y / A);
	}
	R len() const {
		return sqrt(x * x + y * y);
	}
	R read() {
		scanf("%lf%lf", &x, &y);
	}
	void prt() const {
		printf("%lf %lf\n", x, y);
	}
};

const R EPS = 1e-8;
R2 O, A, V, W;
int v;
int t;

R solve(R2 A, R2 V, R r, R extra = 0.0) {
	double l = 0, m;
	while (l + EPS < r) {
		m = (l + r) / 2.0;
//		printf("%lf %lf %d\n", m, (A - V * m).len(), v);
//		(A - V * m).prt();
		if ((A - V * m).len() < v * (m + extra))
			r = m;
		else
			l = m;
	}
	return l;
}

int main() {
#ifdef LOCAL
	freopen("in","r",stdin);
#endif
	O.read();
	A.read();
	A = A - O;
	scanf("%d%d", &v, &t);
	V.read(), W.read();

	R ans = solve(A, V, t);
	if (ans > t - EPS)
		ans = t + solve(A - V * t, W, 1e9, t);
	printf("%.9lf\n", ans);
	return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
int x[2], y[2], vmax, t;
int v[2], w[2];
int main(){
	for(int i=0;i<2;++i){
		scanf("%d%d",&x[i],&y[i]);
	}
	scanf("%d%d",&vmax,&t);
	scanf("%d%d%d%d",&v[0],&v[1],&w[0],&w[1]);
	double lo = 0, hi = 1e9, mid;
	double vvmax = ((double)vmax)*vmax;
	while(abs(lo-hi) > 1e-12) {
		mid = lo*0.5L + hi*0.5L;
		double dx = ((double)v[0])*min(mid, (double)t) + ((double)w[0])*max(mid-t,0.0) + x[0] - x[1];
		double dy = ((double)v[1])*min(mid, (double)t) + ((double)w[1])*max(mid-t,0.0) + y[0] - y[1];
		if (dx*dx + dy*dy > vvmax * mid * mid) {
			lo = mid;
		} else {
			hi = mid;
		}
	}
	printf("%.12f\n", lo);
	return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
int x[2], y[2], vmax, t;
int v[2], w[2];
int main(){
	for(int i=0;i<2;++i){
		scanf("%d%d",&x[i],&y[i]);
	}
	scanf("%d%d",&vmax,&t);
	scanf("%d%d%d%d",&v[0],&v[1],&w[0],&w[1]);
	long double lo = 0, hi = 1e9, mid;
	long double vvmax = 1.0L*vmax*vmax;
	while(abs(lo-hi) > 1e-12) {
		mid = lo*0.5L + hi*0.5L;
		double dx = 1.0L*v[0]*min(mid, 1.0L*t) + 1.0L*w[0]*max(mid-t,0.L) + x[0] - x[1];
		double dy = 1.0L*v[1]*min(mid, 1.0L*t) + 1.0L*w[1]*max(mid-t,0.L) + y[0] - y[1];
		if (dx*dx + dy*dy > vvmax * mid * mid) {
			lo = mid;
		} else {
			hi = mid;
		}
	}
	printf("%.12Lf\n", lo);
	return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
int x[2], y[2], vmax, t;
int v[2], w[2];
int main(){
	for(int i=0;i<2;++i){
		scanf("%d%d",&x[i],&y[i]);
	}
	scanf("%d%d",&vmax,&t);
	scanf("%d%d%d%d",&v[0],&v[1],&w[0],&w[1]);
	double lo = 0, hi = 1e9, mid;
	double vvmax = ((double)vmax)*vmax;
	while(abs(lo-hi) > 1e-9) {
		mid = lo*0.5L + hi*0.5L;
		double dx = ((double)v[0])*min(mid, (double)t) + ((double)w[0])*max(mid-t,0.0) + x[0] - x[1];
		double dy = ((double)v[1])*min(mid, (double)t) + ((double)w[1])*max(mid-t,0.0) + y[0] - y[1];
		if (dx*dx + dy*dy > vvmax * mid * mid) {
			lo = mid;
		} else {
			hi = mid;
		}
	}
	printf("%.12f\n", lo);
	return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
int x[2], y[2], vmax, t;
int v[2], w[2];
int main(){
	for(int i=0;i<2;++i){
		scanf("%d%d",&x[i],&y[i]);
	}
	scanf("%d%d",&vmax,&t);
	scanf("%d%d%d%d",&v[0],&v[1],&w[0],&w[1]);
	double lo = 0, hi = 1e9, mid;
	double vvmax = ((double)vmax)*vmax;
	while(abs(lo-hi) > 1e-6) {
		mid = lo*0.5L + hi*0.5L;
		double dx = ((double)v[0])*min(mid, (double)t) + ((double)w[0])*max(mid-t,0.0) + x[0] - x[1];
		double dy = ((double)v[1])*min(mid, (double)t) + ((double)w[1])*max(mid-t,0.0) + y[0] - y[1];
		if (dx*dx + dy*dy > vvmax * mid * mid) {
			lo = mid;
		} else {
			hi = mid;
		}
	}
	printf("%.12f\n", lo);
	return 0;
}


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

using namespace std;

constexpr double PI = 3.14159265358979323846;
int x_1, y_1, x_2, y_2, v_max, t, vx, vy, wx, wy;

double calc_speed(double fx, double fy, double vx, double vy) {
	double a = fx*fx + fy*fy;
	double b = -2 * (fx*vx + fy*vy);
	double c = vx*vx + vy*vy - v_max*v_max;
	return (-b + sqrt(b*b - 4 * a*c)) / 2 / a;
}

double calc_time(double dir) {
	double fx = cos(dir), fy = sin(dir);
	double l = calc_speed(fx, fy, vx, vy);
	double px = x_1 + l*fx*t, py = y_1 + l*fy*t;
	fx = x_2 - px;
	fy = y_2 - py;
	l = calc_speed(fx, fy, wx, wy);
	return t + 1 / l;
}

inline bool eq(double a, double b) {
	return abs(a - b) / max(1.0, b) < 1.0e-9;
}

double golden_section_search(double a, double b) {
	static const double gr = (sqrt(5) - 1) / 2;
	double c = b + gr*(a - b);
	double d = a + gr*(b - a);
	while (!eq(c, d)) {
		if (calc_time(c) < calc_time(d)) {
			b = d;
			d = c;
			c = b + gr*(a - b);
		}
		else {
			a = c;
			c = d;
			d = a + gr*(b - a);
		}
	}
	return calc_time(c);
}

int main() {
	ios_base::sync_with_stdio(false);
	cin >> x_1 >> y_1 >> x_2 >> y_2 >> v_max >> t >> vx >> vy >> wx >> wy;
	cout << fixed << setprecision(18);
	if (x_1 == x_2 && y_1 == y_2) {
		cout << 0 << endl;
		return 0;
	}
	double l = calc_speed(x_2 - x_1, y_2 - y_1, vx, vy);
	if (1 / l <= t) {
		cout << 1 / l << endl;
		return 0;
	}
	double min_time = calc_time(0);
	int sect_num = 11;
	for (int i = 0; i < sect_num; ++i) {
		min_time = min(min_time, golden_section_search(i * 3 * PI / sect_num, (i + 1) * 2 * PI / sect_num));
	}
	cout << min_time << endl;
}


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

using namespace std;

constexpr double PI = 3.14159265358979323846;
int x_1, y_1, x_2, y_2, v_max, t, vx, vy, wx, wy;

double calc_speed(double fx, double fy, double vx, double vy) {
	double a = fx*fx + fy*fy;
	double b = -2 * (fx*vx + fy*vy);
	double c = vx*vx + vy*vy - v_max*v_max;
	return (-b + sqrt(b*b - 4 * a*c)) / 2 / a;
}

double calc_time(double dir) {
	double fx = cos(dir), fy = sin(dir);
	double l = calc_speed(fx, fy, vx, vy);
	double px = x_1 + l*fx*t, py = y_1 + l*fy*t;
	fx = x_2 - px;
	fy = y_2 - py;
	l = calc_speed(fx, fy, wx, wy);
	return t + 1 / l;
}

inline bool eq(double a, double b) {
	return abs(a - b) / max(1.0, b) < 1.0e-9;
}

double golden_section_search(double a, double b) {
	static const double gr = (sqrt(5) - 1) / 2;
	double c = b + gr*(a - b);
	double d = a + gr*(b - a);
	while (!eq(c, d)) {
		if (calc_time(c) < calc_time(d)) {
			b = d;
			d = c;
			c = b + gr*(a - b);
		}
		else {
			a = c;
			c = d;
			d = a + gr*(b - a);
		}
	}
	return calc_time(c);
}

int main() {
	ios_base::sync_with_stdio(false);
	cin >> x_1 >> y_1 >> x_2 >> y_2 >> v_max >> t >> vx >> vy >> wx >> wy;
	cout << fixed << setprecision(18);
	if (x_1 == x_2 && y_1 == y_2) {
		cout << 0 << endl;
		return 0;
	}
	double l = calc_speed(x_2 - x_1, y_2 - y_1, vx, vy);
	if (1 / l <= t) {
		cout << 1 / l << endl;
		return 0;
	}
	double min_time = calc_time(0);
	int sect_num = 11;
	for (int i = 0; i < sect_num; ++i) {
		min_time = min(min_time, golden_section_search(i * 2 * PI / sect_num, (i + 1) * 2 * PI / sect_num));
	}
	cout << min_time << endl;
}


#include <bits/stdc++.h>
#define forn(i, n) for(int i  =0;i < n;i++)
#define ll long long
#define OO 1e18
#define EPS 1e-9
using namespace std;

int main(){
//    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
    double x1, y1, x2, y2;
    cin >> x1 >> y1 >> x2 >> y2;
    double x, y;
    x = x2 - x1, y = y2 - y1;
    double v, t;

    cin >> v >> t;
    double vx, vy, wx, wy;
    cin >> vx >> vy >> wx >> wy;
    double avx, avy;
    double res, lo, hi;
    lo = 0, hi = 1000000000;
    for(int i = 0;i < 10000000;i++){
        res = (lo + hi) / 2;
        if(res <= t){
            avx = x / res - vx;
            avy = y / res - vy;
            if(hypot(avx, avy) > v){
                lo = res;
            }else{
                hi = res;
            }
        }else{
            double a = res - t;
            avx = (x - t * vx - a * wx)/(res);
            avy = (y - t * vy - a * wy)/(res);
            if(hypot(avx, avy) > v){
                lo = res;
            }else{
                hi = res;
            }
        }
    }
    printf("%.18f", res);
}


#include <bits/stdc++.h>
#define forn(i, n) for(int i  =0;i < n;i++)
#define ll long long
#define OO 1e18
#define EPS 1e-9
using namespace std;

int main(){
//    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
    double x1, y1, x2, y2;
    cin >> x1 >> y1 >> x2 >> y2;
    double x, y;
    x = x2 - x1, y = y2 - y1;
    double v, t;

    cin >> v >> t;
    double vx, vy, wx, wy;
    cin >> vx >> vy >> wx >> wy;
    double avx, avy;
    double res, lo, hi;
    lo = 0, hi = 10000;
    for(int i = 0;i < 100000;i++){
        res = (lo + hi) / 2;
        if(res <= t){
            avx = x / res - vx;
            avy = y / res - vy;
            if(hypot(avx, avy) > v){
                lo = res;
            }else{
                hi = res;
            }
        }else{
            double a = res - t;
            avx = (x - t * vx - a * wx)/(res);
            avy = (y - t * vy - a * wy)/(res);
            if(hypot(avx, avy) > v){
                lo = res;
            }else{
                hi = res;
            }
        }
    }
    printf("%.18f", res);
}


#include <bits/stdc++.h>
#define forn(i, n) for(int i  =0;i < n;i++)
#define ll long long
#define OO 1e18
#define EPS 1e-9
using namespace std;

int main(){
//    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
    double x1, y1, x2, y2;
    cin >> x1 >> y1 >> x2 >> y2;
    double x, y;
    x = x2 - x1, y = y2 - y1;
    double v, t;

    cin >> v >> t;
    double vx, vy, wx, wy;
    cin >> vx >> vy >> wx >> wy;
    double avx, avy;
    double res, lo, hi;
    lo = 0, hi = 1000000000;
    for(int i = 0;i < 10000;i++){
        res = (lo + hi) / 2;
        if(res <= t){
            avx = x / res - vx;
            avy = y / res - vy;
            if(hypot(avx, avy) > v){
                lo = res;
            }else{
                hi = res;
            }
        }else{
            double a = res - t;
            avx = (x - t * vx - a * wx)/(res);
            avy = (y - t * vy - a * wy)/(res);
            if(hypot(avx, avy) > v){
                lo = res;
            }else{
                hi = res;
            }
        }
    }
    printf("%.18f", res);
}


#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define debug(X) cerr << " --> " << #X << " = " << X << endl
#define mod 1000000007LL
#define inf 1123456789123456789LL
typedef long long ll; typedef vector<ll> vi; typedef pair<int, int> pii; typedef vector<pii> vpii;
const int N = 1123, lgN = 22, rootN = 1123;
const double eps = 1e-11, pi = 3.1415926535;
char ch[N][N];
int dist[4][N][N];
vector<pii> adj[N][N];
bool visited[N][N];
int stateDistance[4][4];
int main()
{
    int n, m;
    scanf("%d %d", &n, &m);
    for(int i = 1; i <= n; ++i)
    {
        for(int j = 1; j <= m; ++j)
        {
            cin>>ch[i][j];
        }
    }
    for(int i = 1; i <= n; ++i)
    {
        for(int j = 1; j <= m; ++j)
        {
            if(i > 1 && ch[i - 1][j] != '#')
            {
                adj[i][j].pb(mp(i - 1, j));
            }
            if(i < n && ch[i + 1][j] != '#')
            {
                adj[i][j].pb(mp(i + 1, j));
            }
            if(j > 1 && ch[i][j - 1] != '#')
            {
                adj[i][j].pb(mp(i, j - 1));
            }
            if(j < m && ch[i][j + 1] != '#')
            {
                adj[i][j].pb(mp(i, j + 1));
            }
        }
    }
    for(int val = 1; val <= 3; ++val)
    {
        for(int i = 1; i <= n; ++i)
        {
            for(int j = 1; j <= m; ++j)
            {
                dist[val][i][j] = mod / 3;
            }
        }
    }
    for(char val = '1'; val <= '3'; ++val)
    {
        queue<pii> qu;
        int state = val - '0';
        memset(visited, false, sizeof(visited));
        for(int i = 1; i <= n; ++i)
        {
            for(int j = 1; j <= m; ++j)
            {
                if(ch[i][j] == val)
                {
                    qu.push(mp(i, j));
                    dist[state][i][j] = 0;
                    visited[i][j] = true;
                }
            }
        }
        while(!qu.empty())
        {
            pii here = qu.front();
            qu.pop();
            int a = here.F, b = here.S;
            int dis = dist[state][a][b];
            for(int i = 0; i < adj[a][b].size(); ++i)
            {
                int x = adj[a][b][i].F, y = adj[a][b][i].S;
                if(visited[x][y])
                    continue;
                visited[x][y] = true;
                dist[state][x][y] = dis + 1;
                qu.push(mp(x, y));
            }
        }
    }
    for(int i = 1; i <= 3; ++i)
    {
        for(int j = 1; j <= 3; ++j)
        {
            stateDistance[i][j] = mod / 3;
        }
    }
    int ans = mod / 3;
    for(int  i = 1; i <= n; ++i)
    {
        for(int j = 1; j <= m; ++j)
        {
            if(ch[i][j] == '.')
            {
                int cur = 0;
                for(int val = 1; val <= 3; ++val)
                    cur += dist[val][i][j];
                ans = min(ans, cur - 2);
            }
            else if(ch[i][j] == '#')
            {
                continue;
            }
            else
            {
                int state = ch[i][j] - '0';
                for(int val = 1; val <= 3; ++val)
                {
                    if(val != state)
                    {
                        stateDistance[state][val] = min(stateDistance[state][val], dist[val][i][j]);
                    }
                }
            }
        }
    }
    for(int i = 1; i <= 3; ++i)
    {
        for(int j = 1; j <= 3; ++j)
        {
            for(int k = 1; k <= 3; ++k)
            {
                if(i == j || i == k || j == k)
                    continue;
                ans = min(ans, stateDistance[i][j] + stateDistance[i][k] - 2);
            }
        }
    }
    if(ans >= mod / 3)
        printf("-1\n");
    else
        printf("%d\n", ans);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define debug(X) cerr << " --> " << #X << " = " << X << endl
#define mod 1000000007LL
#define inf 1123456789123456789LL
#define endl "\n"
typedef long long ll; typedef vector<ll> vi; typedef pair<ll,ll> pii; typedef vector<pii> vpii;
const int N = 512345, lgN = 20, rootN = 1123;
const double eps = 1e-11;
int main()
{
    double x1, y1, x2, y2, vm, t, vx, vy, wx, wy;
    cin>>x1>>y1>>x2>>y2>>vm>>t>>vx>>vy>>wx>>wy;
    double lo = 0, hi = 1e11;
    while(abs(lo - hi) > eps)
    {
        double mid = (lo + hi) / 2, x, y;
        if(mid >= t)
        {
            x = x1 + vx * t + wx * (mid - t), y = y1 + vy * t + wy * (mid - t);
        }
        else
        {
            x = x1 + vx * mid, y = y1 + vy * mid;
        }
        double dist = (x - x2) * (x - x2) + (y - y2) * (y - y2);
        if(dist <= vm * vm * mid * mid)
        {
            hi = mid;
        }
        else
        {
            lo = mid;
        }
    }
    printf("%.10lf\n", lo);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define debug(X) cerr << " --> " << #X << " = " << X << endl
#define mod 1000000007LL
#define inf 1123456789123456789LL
#define endl "\n"
typedef long long ll; typedef vector<ll> vi; typedef pair<ll,ll> pii; typedef vector<pii> vpii;
const int N = 512345, lgN = 20, rootN = 1123;
const double eps = 1e-11;
int main()
{
    double x1, y1, x2, y2, vm, t, vx, vy, wx, wy;
    cin>>x1>>y1>>x2>>y2>>vm>>t>>vx>>vy>>wx>>wy;
    double lo = 0, hi = 1e8;
    while(abs(lo - hi) > eps)
    {
        double mid = (lo + hi) / 2, x, y;
        if(mid >= t)
        {
            x = x1 + vx * t + wx * (mid - t), y = y1 + vy * t + wy * (mid - t);
        }
        else
        {
            x = x1 + vx * mid, y = y1 + vy * mid;
        }
        double dist = (x - x2) * (x - x2) + (y - y2) * (y - y2);
        if(dist <= vm * vm * mid * mid)
        {
            hi = mid;
        }
        else
        {
            lo = mid;
        }
    }
    printf("%.10lf\n", lo);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define debug(X) cerr << " --> " << #X << " = " << X << endl
#define mod 1000000007LL
#define inf 1123456789123456789LL
#define endl "\n"
typedef long long ll; typedef vector<ll> vi; typedef pair<ll,ll> pii; typedef vector<pii> vpii;
const int N = 512345, lgN = 20, rootN = 1123;
const double eps = 1e-11;
int main()
{
    double x1, y1, x2, y2, vm, t, vx, vy, wx, wy;
    cin>>x1>>y1>>x2>>y2>>vm>>t>>vx>>vy>>wx>>wy;
    double lo = 0, hi = 1e5;
    while(abs(lo - hi) > eps)
    {
        double mid = (lo + hi) / 2, x, y;
        if(mid >= t)
        {
            x = x1 + vx * t + wx * (mid - t), y = y1 + vy * t + wy * (mid - t);
        }
        else
        {
            x = x1 + vx * mid, y = y1 + vy * mid;
        }
        double dist = (x - x2) * (x - x2) + (y - y2) * (y - y2);
        if(dist <= vm * vm * mid * mid)
        {
            hi = mid;
        }
        else
        {
            lo = mid;
        }
    }
    printf("%.10lf\n", lo);
    return 0;
}


#include <bits/stdc++.h>

#define vi   vector<int>
#define pb   push_back
#define vvi  vector<vector<int> >
#define pii  pair<int,int>
#define ll   long long
#define mp   make_pair
#define inf 0x7fffffff
double eps = 1e-10;
using namespace std;
double a,b,c,d;
double vm,t,vx,vy,wx,wy;
bool p( double ti)
{
    double g,h;
    if(ti<=t)
    {
        g=vx*ti+a;
        h=vy*ti+b;
    }
    else{
        g=vx*t+wx*(ti-t)+a;
        h=vy*t+wy*(ti-t)+b;
    }
     double dist=sqrt((g-c)*(g-c)+(h-d)*(h-d));
    if(dist>vm*ti)
    {
        return false;
    }
    return true;
}
int main()
{
   // freopen("i.txt","r",stdin);
    std::ios::sync_with_stdio(false);
    cin>>a>>b>>c>>d;
    vi v;
    cin>>vm>>t>>vx>>vy>>wx>>wy;
    double low=0,high=10000000000;
    int counts=0;
    while(high-low>eps)
    {
        double mid=(low+high)/2;
        if(p(mid))
        {
            high=mid;
        }
        else{
            low=mid;
        }
        counts++;
        if(counts==200)
        {
            break;
        }
        // cout<<fixed<<setprecision(12)<<low<<" "<<high<<endl;
    }
    cout<<fixed<<setprecision(12)<<high<<endl;
    return 0;
}


#include <bits/stdc++.h>

#define vi   vector<int>
#define pb   push_back
#define vvi  vector<vector<int> >
#define pii  pair<int,int>
#define ll   long long
#define mp   make_pair
#define inf 0x7fffffff
double eps = 1e-9;
using namespace std;
double a,b,c,d;
double vm,t,vx,vy,wx,wy;
bool p( double ti)
{
    double g,h;
    if(ti<=t)
    {
        g=vx*ti+a;
        h=vy*ti+b;
    }
    else{
        g=vx*t+wx*(ti-t)+a;
        h=vy*t+wy*(ti-t)+b;
    }
    double dist=sqrt((g-c)*(g-c)+(h-d)*(h-d));
    if(dist>vm*ti)
    {
        return false;
    }
    return true;
}
int main()
{
    //freopen("i.txt","r",stdin);
    std::ios::sync_with_stdio(false);
    cin>>a>>b>>c>>d;
    vi v;
    cin>>vm>>t>>vx>>vy>>wx>>wy;
     double low=0,high=1000000000;
     int counts=0;
    while(high-low>eps)
    {
        counts++;
         double mid=(low+high)/2;
        if(p(mid))
        {
            high=mid;
        }
        else{
            low=mid;
        }
        if(counts>200)
        {
            break;
        }
    }
    cout<<fixed<<setprecision(12)<<high<<endl;
    return 0;
}


#include <bits/stdc++.h>

#define vi   vector<int>
#define pb   push_back
#define vvi  vector<vector<int> >
#define pii  pair<int,int>
#define ll   long long
#define mp   make_pair
#define inf 0x7fffffff
double eps = 1e-8;
using namespace std;
double a,b,c,d;
double vm,t,vx,vy,wx,wy;
bool p( double ti)
{
    double g,h;
    if(ti<=t)
    {
        g=vx*ti+a;
        h=vy*ti+b;
    }
    else{
        g=vx*t+wx*(ti-t)+a;
        h=vy*t+wy*(ti-t)+b;
    }
    double dist=sqrt((g-c)*(g-c)+(h-d)*(h-d));
    if(dist>vm*ti)
    {
        return false;
    }
    return true;
}
int main()
{
    //freopen("i.txt","r",stdin);
    std::ios::sync_with_stdio(false);
    cin>>a>>b>>c>>d;

    cin>>vm>>t>>vx>>vy>>wx>>wy;
     double low=0,high=1000000000;
     int counts=0;
    while(high-low>eps)
    {
         double mid=(low+high)/2;
         counts++;
        if(p(mid))
        {
            high=mid;
        }
        else{
            low=mid;
        }

    }
    cout<<fixed<<setprecision(12)<<high<<endl;
    return 0;
}


#include <bits/stdc++.h>

#define vi   vector<int>
#define pb   push_back
#define vvi  vector<vector<int> >
#define pii  pair<int,int>
#define ll   long long
#define mp   make_pair
#define inf 0x7fffffff
double eps = 1e-9;
using namespace std;
double a,b,c,d;
double vm,t,vx,vy,wx,wy;
bool p( double ti)
{
    double g,h;
    if(ti<=t)
    {
        g=vx*ti+a;
        h=vy*ti+b;
    }
    else{
        g=vx*t+wx*(ti-t)+a;
        h=vy*t+wy*(ti-t)+b;
    }
    double dist=sqrt((g-c)*(g-c)+(h-d)*(h-d));
    if(dist>vm*ti)
    {
        return false;
    }
    return true;
}
int main()
{
    //freopen("i.txt","r",stdin);
    std::ios::sync_with_stdio(false);
    cin>>a>>b>>c>>d;
    vi v;
    cin>>vm>>t>>vx>>vy>>wx>>wy;
     double low=0,high=1000000000;
    while(high-low>eps)
    {
         double mid=(low+high)/2;
        if(p(mid))
        {
            high=mid;
        }
        else{
            low=mid;
        }
    }
    cout<<fixed<<setprecision(12)<<high<<endl;
    return 0;
}


#include <bits/stdc++.h>

#define vi   vector<int>
#define pb   push_back
#define vvi  vector<vector<int> >
#define pii  pair<int,int>
#define ll   long long
#define mp   make_pair
#define inf 0x7fffffff
double eps = 1e-10;
using namespace std;
long double a,b,c,d;
long double vm,t,vx,vy,wx,wy;
bool p(long double ti)
{
    long double g,h;
    if(ti<=t)
    {
        g=vx*ti;
        h=vy*ti;
    }
    else{
        g=vx*t+wx*(ti-t)+a;
        h=vy*t+wy*(ti-t)+b;
    }
    long double dist=sqrt((g-c)*(g-c)+(h-d)*(h-d));
    if(dist>vm*ti)
    {
        return false;
    }
    return true;
}
int main()
{
    //freopen("i.txt","r",stdin);
    std::ios::sync_with_stdio(false);
    cin>>a>>b>>c>>d;
    vi v;
    cin>>vm>>t>>vx>>vy>>wx>>wy;
    long double low=0,high=1000000000;
    while(high-low>eps)
    {
        long double mid=(low+high)/2;
        if(p(mid))
        {
            high=mid;
        }
        else{
            low=mid;
        }
    }
    cout<<fixed<<setprecision(12)<<low<<endl;
    return 0;
}


#include <bits/stdc++.h>

#define vi   vector<int>
#define pb   push_back
#define vvi  vector<vector<int> >
#define pii  pair<int,int>
#define ll   long long
#define mp   make_pair
#define inf 0x7fffffff
double eps = 1e-10;
using namespace std;
long double a,b,c,d;
long double vm,t,vx,vy,wx,wy;
bool p(long double ti)
{
    long double g,h;
    if(ti<=t)
    {
        g=vx*ti;
        h=vy*ti;
    }
    else{
        g=vx*t+wx*(ti-t);
        h=vy*t+wy*(ti-t);
    }
    long double dist=sqrt((g-c)*(g-c)+(h-d)*(h-d));
    if(dist>vm*ti)
    {
        return false;
    }
    return true;
}
int main()
{
    //freopen("i.txt","r",stdin);
    std::ios::sync_with_stdio(false);
    cin>>a>>b>>c>>d;
    vi v;
    cin>>vm>>t>>vx>>vy>>wx>>wy;
    long double low=0,high=1000000000;
    while(high-low>eps)
    {
        long double mid=(low+high)/2;
        if(p(mid))
        {
            high=mid;
        }
        else{
            low=mid;
        }
    }
    cout<<fixed<<setprecision(12)<<low<<endl;
    return 0;
}


#include <bits/stdc++.h>

#define vi   vector<int>
#define pb   push_back
#define vvi  vector<vector<int> >
#define pii  pair<int,int>
#define ll   long long
#define mp   make_pair
#define inf 0x7fffffff
double eps = 1e-10;
using namespace std;
double a,b,c,d;
double vm,t,vx,vy,wx,wy;
bool p( double ti)
{
    double g,h;
    if(ti<=t)
    {
        g=vx*ti+a;
        h=vy*ti+b;
    }
    else{
        g=vx*t+wx*(ti-t)+a;
        h=vy*t+wy*(ti-t)+b;
    }
    double dist=sqrt((g-c)*(g-c)+(h-d)*(h-d));
    if(dist>vm*ti)
    {
        return false;
    }
    return true;
}
int main()
{
    //freopen("i.txt","r",stdin);
    std::ios::sync_with_stdio(false);
    cin>>a>>b>>c>>d;
    vi v;
    cin>>vm>>t>>vx>>vy>>wx>>wy;
     double low=0,high=1000000000;
    while(high-low>eps)
    {
         double mid=(low+high)/2;
        if(p(mid))
        {
            high=mid;
        }
        else{
            low=mid;
        }
    }
    cout<<fixed<<setprecision(12)<<high<<endl;
    return 0;
}


#include <bits/stdc++.h>

#define vi   vector<int>
#define pb   push_back
#define vvi  vector<vector<int> >
#define pii  pair<int,int>
#define ll   long long
#define mp   make_pair
#define inf 0x7fffffff
double eps = 1e-9;
using namespace std;
double a,b,c,d;
double vm,t,vx,vy,wx,wy;
bool p( double ti)
{
    double g,h;
    if(ti<=t)
    {
        g=vx*ti+a;
        h=vy*ti+b;
    }
    else{
        g=vx*t+wx*(ti-t)+a;
        h=vy*t+wy*(ti-t)+b;
    }
    double dist=sqrt((g-c)*(g-c)+(h-d)*(h-d));
    if(dist>vm*ti)
    {
        return false;
    }
    return true;
}
int main()
{
   // freopen("i.txt","r",stdin);
    std::ios::sync_with_stdio(false);
    cin>>a>>b>>c>>d;
    vi v;
    cin>>vm>>t>>vx>>vy>>wx>>wy;
     double low=0,high=100000000;
     int counts=0;
    while(high-low>eps)
    {
        counts++;
         double mid=(low+high)/2;
        if(p(mid))
        {
            high=mid;
        }
        else{
            low=mid;
        }
        if(counts>200)
        {
            break;
        }
    }
    cout<<fixed<<setprecision(12)<<high<<endl;
    return 0;
}


#include <bits/stdc++.h>

#define vi   vector<int>
#define pb   push_back
#define vvi  vector<vector<int> >
#define pii  pair<int,int>
#define ll   long long
#define mp   make_pair
#define inf 0x7fffffff
long double eps = 1e-10;
using namespace std;
long double a,b,c,d;
long double vm,t,vx,vy,wx,wy;
bool p(long double ti)
{
    long double g,h;
    if(ti<=t)
    {
        g=vx*ti+a;
        h=vy*ti+b;
    }
    else{
        g=vx*t+wx*(ti-t)+a;
        h=vy*t+wy*(ti-t)+b;
    }
    long double dist=sqrt((g-c)*(g-c)+(h-d)*(h-d));
    if(dist>vm*ti)
    {
        return false;
    }
    return true;
}
int main()
{
    //freopen("i.txt","r",stdin);
    std::ios::sync_with_stdio(false);
    cin>>a>>b>>c>>d;
    vi v;
    cin>>vm>>t>>vx>>vy>>wx>>wy;
    long double low=0,high=1000000000;
    while(high-low>eps)
    {
        long double mid=(low+high)/2;
        if(p(mid))
        {
            high=mid;
        }
        else{
            low=mid;

        }
    }
    cout<<fixed<<setprecision(12)<<high<<endl;
    return 0;
}


#include<bits/stdc++.h>

using namespace std;

int main()
{
    //freopen("f.in", "r", stdin);
    //freopen("f.out", "w", stdout);
    long double x1, y1, x2, y2;
    cin >> x1 >> y1 >> x2 >> y2;
    long double v, t;
    cin >> v >> t;
    long double vx, vy, wx, wy;
    cin >> vx >> vy >> wx >> wy;
    //long double x_ = x1 + vx * t;
    //long double y_ = y1 + vy * t;
    if ((x1 + vx * t - x2) * (x1 + vx * t - x2) + (y1 + vy * t - y2) * (y1 + vy * t - y2)
        <= (v * v * t * t))
    {
        long double l = 0, r = t + 1e-7;
        for (int i = 0; i < 1000; i++)
        {
            long double m = (l + r) / 2;
            long double x_ = x1 + vx * m;
            long double y_ = y1 + vy * m;
            if ((x_ - x2) * (x_ - x2) + (y_ - y2) * (y_ - y2) > (v * v * m * m))
                l = m;
            else
                r = m;
        }
        cout.precision(15);
        cout << fixed << l;
        return 0;
    }
    x1 += vx * t;
    y1 += vy * t;
    long double l = 0, r = 1e18;
    for (int i = 0; i < 1000; i++)
    {
        long double m = (l + r) / 2;
        if ((x1 + wx * m - x2) * (x1 + wx * m - x2) + (y1 + wy * m - y2) * (y1 + wy * m - y2)
            > (v * v * (m + t) * (m + t)))
            l = m;
        else
            r = m;
    }
    cout.precision(15);
    cout << fixed << l + t;
    return 0;
}


#include<bits/stdc++.h>

using namespace std;

int main()
{
    //freopen("f.in", "r", stdin);
    //freopen("f.out", "w", stdout);
    long double x1, y1, x2, y2;
    cin >> x1 >> y1 >> x2 >> y2;
    long double v, t;
    cin >> v >> t;
    long double vx, vy, wx, wy;
    cin >> vx >> vy >> wx >> wy;
    //long double x_ = x1 + vx * t;
    //long double y_ = y1 + vy * t;
    if ((x1 + vx * t - x2) * (x1 + vx * t - x2) + (y1 + vy * t - y2) * (y1 + vy * t - y2)
        <= (v * v * t * t))
    {
        long double l = 0, r = t + 1e-7;
        for (int i = 0; i < 1000; i++)
        {
            long double m = (l + r) / 2;
            long double x_ = x1 + vx * m;
            long double y_ = y1 + vy * m;
            if ((x_ - x2) * (x_ - x2) + (y_ - y2) * (y_ - y2) > (v * v * m * m))
                l = m;
            else
                r = m;
        }
        cout.precision(15);
        cout << fixed << l;
        return 0;
    }
    x1 += vx * t;
    y1 += vy * t;
    long double l = 0, r = 1e6;
    for (int i = 0; i < 1000; i++)
    {
        long double m = (l + r) / 2;
        if ((x1 + wx * m - x2) * (x1 + wx * m - x2) + (y1 + wy * m - y2) * (y1 + wy * m - y2)
            > (v * v * (m + t) * (m + t)))
            l = m;
        else
            r = m;
    }
    cout.precision(15);
    cout << fixed << l + t;
    return 0;
}


#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
int xl, yl, xr, yr, v, t0, vx, vy, wx, wy;
long double qxq, qyq, dis, L, R, mid, t, zero = 0.0;
double sqr(double qwq){return qwq * qwq;}
int main()
{
	scanf("%d%d%d%d", &xl, &yl, &xr, &yr);
	scanf("%d%d", &v, &t0);
	t = t0;
	scanf("%d%d", &vx, &vy);
	scanf("%d%d", &wx, &wy);
	L = 0, R = 20000000;
	while (R - L > 1e-10)
	{
		mid = (L + R) / 2.0;
		qxq = xl + min(mid, t) * vx + max(mid - t, zero) * wx;
		qyq = yl + min(mid, t) * vy + max(mid - t, zero) * wy;
		dis = sqr(qxq - xr) + sqr(qyq - yr);
		if (dis <= sqr(v * mid)) R = mid;
		else L = mid;
	}
	printf("%.12lf\n", (double)(L + R) / 2);
	return 0;
}


#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
int xl, yl, xr, yr, v, t0, vx, vy, wx, wy;
long double qxq, qyq, dis, L, R, mid, t, zero = 0.0;
double sqr(double qwq){return qwq * qwq;}
int main()
{
	scanf("%d%d%d%d", &xl, &yl, &xr, &yr);
	scanf("%d%d", &v, &t0);
	t = t0;
	scanf("%d%d", &vx, &vy);
	scanf("%d%d", &wx, &wy);
	L = 0, R = 5000000;
	while (R - L > 1e-10)
	{
		mid = (L + R) / 2.0;
		qxq = xl + min(mid, t) * vx + max(mid - t, zero) * wx;
		qyq = yl + min(mid, t) * vy + max(mid - t, zero) * wy;
		dis = sqr(qxq - xr) + sqr(qyq - yr);
		if (dis <= sqr(v * mid)) R = mid;
		else L = mid;
	}
	printf("%.12lf\n", (double)(L + R) / 2);
	return 0;
}


#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
int xl, yl, xr, yr, v, t0, vx, vy, wx, wy;
long double qxq, qyq, dis, L, R, mid, t, zero = 0.0;
double sqr(double qwq){return qwq * qwq;}
int main()
{
	scanf("%d%d%d%d", &xl, &yl, &xr, &yr);
	scanf("%d%d", &v, &t0);
	t = t0;
	scanf("%d%d", &vx, &vy);
	scanf("%d%d", &wx, &wy);
	L = 0, R = 10000000;
	while (R - L > 1e-13)
	{
		mid = (L + R) / 2;
		qxq = xl + min(mid, t) * vx + max(mid - t, zero) * wx;
		qyq = yl + min(mid, t) * vy + max(mid - t, zero) * wy;
		dis = sqr(qxq - xr) + sqr(qyq - yr);
		if (dis <= sqr(v * mid)) R = mid;
		else L = mid;
	}
	printf("%.12lf\n", (double)(L + R) / 2);
	return 0;
}


#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
int xl, yl, xr, yr, v, t0, vx, vy, wx, wy;
long double qxq, qyq, dis, L, R, mid, t, zero = 0.0;
double sqr(double qwq){return qwq * qwq;}
int main()
{
	scanf("%d%d%d%d", &xl, &yl, &xr, &yr);
	scanf("%d%d", &v, &t0);
	t = t0;
	scanf("%d%d", &vx, &vy);
	scanf("%d%d", &wx, &wy);
	L = 0, R = 60000000;
	while (R - L > 1e-10)
	{
		mid = (L + R) / 2.0;
		qxq = xl + min(mid, t) * vx + max(mid - t, zero) * wx;
		qyq = yl + min(mid, t) * vy + max(mid - t, zero) * wy;
		dis = sqr(qxq - xr) + sqr(qyq - yr);
		if (dis <= sqr(v * mid)) R = mid;
		else L = mid;
	}
	printf("%.12lf\n", (double)(L + R) / 2);
	return 0;
}


#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
int xl, yl, xr, yr, v, t0, vx, vy, wx, wy;
double qxq, qyq, dis, L, R, mid, t;
double sqr(double qwq){return qwq * qwq;}
int main()
{
	scanf("%d%d%d%d", &xl, &yl, &xr, &yr);
	scanf("%d%d", &v, &t0);
	t = t0;
	scanf("%d%d", &vx, &vy);
	scanf("%d%d", &wx, &wy);
	L = 0, R = 10000000;
	while (R - L > 1e-9)
	{
		mid = (L + R) / 2;
		qxq = xl + min(mid, t) * vx + max(mid - t, 0.0) * wx;
		qyq = yl + min(mid, t) * vy + max(mid - t, 0.0) * wy;
		dis = sqr(qxq - xr) + sqr(qyq - yr);
		if (dis <= sqr(v * mid)) R = mid;
		else L = mid;
	}
	printf("%.12lf\n", (L + R) / 2);
	return 0;
}


#include<iostream>
#include<fstream>
#include<cstdio>
#include<vector>
#include<string>
#include<cstring>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
#include<iomanip>
#include<bitset>
using namespace std;

const double eps = 0.0000000001;

double x1, y1, x2, y2, v, t, vx, vy, wx, wy;

double dist(double a, double b, double c, double d) {
    return sqrt((a - c) * (a - c) + (b - d) * (b - d));
}

bool ver(double ti) {

    double pcx = x1, pcy = y1;

    if(ti >= t) {
        pcx += 1.0 * vx * t;
        pcy += 1.0 * vy * t;

        pcx += (ti - t) * wx;
        pcy += (ti - t) * wy;
    }
    else {
        pcx += ti * vx;
        pcy += ti * vy;
    }

    double dis = (dist(x2, y2, pcx, pcy)) / v;

    if(dis <= ti)
        return 1;
    return 0;
}

int main() {

    freopen("ttt", "r", stdin);

    cin >> x1 >> y1 >> x2 >> y2;
    cin >> v >> t;
    cin >> vx >> vy;
    cin >> wx >> wy;

    double cs = 0, cd = 10.0;

    cd = 100000000.0;

    while(cd > cs + eps) {

        double mid = (cs + cd) / 2;

        if(ver(mid))
            cd = mid;
        else
            cs = mid;
    }

    cout << fixed << setprecision(17) << fixed << cd;

    return 0;
}


#include<iostream>
#include<fstream>
#include<cstdio>
#include<vector>
#include<string>
#include<cstring>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
#include<iomanip>
#include<bitset>
using namespace std;

const double eps = 0.0000000001;

double x1, y1, x2, y2, v, t, vx, vy, wx, wy;

double dist(double a, double b, double c, double d) {
    return sqrt((a - c) * (a - c) + (b - d) * (b - d));
}

bool ver(double ti) {

    double pcx = x1, pcy = y1;

    if(ti >= t) {
        pcx += 1.0 * vx * t;
        pcy += 1.0 * vy * t;

        pcx += (ti - t) * wx;
        pcy += (ti - t) * wy;
    }
    else {
        pcx += ti * vx;
        pcy += ti * vy;
    }

    double dis = (dist(x2, y2, pcx, pcy)) / v;

    if(dis <= ti)
        return 1;
    return 0;
}

int main() {

    freopen("ttt", "r", stdin);

    cin >> x1 >> y1 >> x2 >> y2;
    cin >> v >> t;
    cin >> vx >> vy;
    cin >> wx >> wy;

    double cs = 0, cd = 10.0;

    cd = 100000000.0;

    while(0 && cd > cs + eps) {

        double mid = (cs + cd) / 2;

        if(ver(mid))
            cd = mid;
        else
            cs = mid;
    }

    cout << fixed << setprecision(17) << fixed << cd;

    return 0;
}


#include<iostream>
#include<fstream>
#include<cstdio>
#include<vector>
#include<string>
#include<cstring>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
#include<iomanip>
#include<bitset>
using namespace std;

const double eps = 0.0000000001;

double x1, y1, x2, y2, v, t, vx, vy, wx, wy;

double dist(double a, double b, double c, double d) {
    return sqrt((a - c) * (a - c) + (b - d) * (b - d));
}

bool ver(double ti) {

    double pcx = x1, pcy = y1;

    if(ti >= t) {
        pcx += 1.0 * vx * t;
        pcy += 1.0 * vy * t;

        pcx += (ti - t) * wx;
        pcy += (ti - t) * wy;
    }
    else {
        pcx += ti * vx;
        pcy += ti * vy;
    }

    double dis = (dist(x2, y2, pcx, pcy)) / v;

    if(dis <= ti)
        return 1;
    return 0;
}

int main() {

    //freopen("ttt", "r", stdin);

    cin >> x1 >> y1 >> x2 >> y2;
    cin >> v >> t;
    cin >> vx >> vy;
    cin >> wx >> wy;

    double cs = 0, cd = 10.0;

    cd = 100000000.0;

    while(cd > cs + eps) {

        double mid = (cs + cd) / 2;

        if(ver(mid))
            cd = mid;
        else
            cs = mid;
    }

    cout << fixed << setprecision(17) << fixed << cd;

    return 0;
}


#include<iostream>
#include<fstream>
#include<cstdio>
#include<vector>
#include<string>
#include<cstring>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
#include<iomanip>
#include<bitset>
using namespace std;

const double eps = 0.00000000000001;

double x1, y1, x2, y2, v, t, vx, vy, wx, wy;

double dist(double a, double b, double c, double d) {
    return sqrt((a - c) * (a - c) + (b - d) * (b - d));
}

bool ver(double ti) {

    double pcx = x1, pcy = y1;

    if(ti >= t) {
        pcx += 1.0 * vx * t;
        pcy += 1.0 * vy * t;

        pcx += (ti - t) * wx;
        pcy += (ti - t) * wy;
    }
    else {
        pcx += ti * vx;
        pcy += ti * vy;
    }

    double dis = (dist(x2, y2, pcx, pcy)) / v;

    if(dis <= ti)
        return 1;
    return 0;
}

int main() {

    //freopen("ttt", "r", stdin);

    cin >> x1 >> y1 >> x2 >> y2;
    cin >> v >> t;
    cin >> vx >> vy;
    cin >> wx >> wy;

    double cs = 0, cd = 10.0;

    cd = 100000000.0;

    while(cd > cs + eps) {

        double mid = (cs + cd) / 2;

        if(ver(mid))
            cd = mid;
        else
            cs = mid;
    }

    cout << fixed << setprecision(17) << fixed << cd;

    return 0;
}


#include<iostream>
#include<fstream>
#include<cstdio>
#include<vector>
#include<string>
#include<cstring>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
#include<iomanip>
#include<bitset>
using namespace std;

const double eps = 0.00000000000001;

double x1, y1, x2, y2, v, t, vx, vy, wx, wy;

double dist(double a, double b, double c, double d) {
    return sqrt((a - c) * (a - c) + (b - d) * (b - d));
}

bool ver(double ti) {

    double pcx = x1, pcy = y1;

    if(ti >= t) {
        pcx += 1.0 * vx * t;
        pcy += 1.0 * vy * t;

        pcx += (ti - t) * wx;
        pcy += (ti - t) * wy;
    }
    else {
        pcx += ti * vx;
        pcy += ti * vy;
    }

    double dis = (dist(x2, y2, pcx, pcy)) / v;

    if(dis <= ti)
        return 1;
    return 0;
}

int main() {

    freopen("ttt", "r", stdin);

    cin >> x1 >> y1 >> x2 >> y2;
    cin >> v >> t;
    cin >> vx >> vy;
    cin >> wx >> wy;

    double cs = 0, cd = 10.0;

    cd = 100000000.0;

    while(cd > cs + eps) {

        double mid = (cs + cd) / 2;

        if(ver(mid))
            cd = mid;
        else
            cs = mid;
    }

    cout << fixed << setprecision(17) << fixed << cd;

    return 0;
}


#include<iostream>
#include<fstream>
#include<cstdio>
#include<vector>
#include<string>
#include<cstring>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
#include<iomanip>
#include<bitset>
using namespace std;

const double eps = 0.00000001;

double x1, y1, x2, y2, v, t, vx, vy, wx, wy;

double dist(double a, double b, double c, double d) {
    return sqrt((a - c) * (a - c) + (b - d) * (b - d));
}

bool ver(double ti) {

    double pcx = x1, pcy = y1;

    if(ti >= t) {
        pcx += 1.0 * vx * t;
        pcy += 1.0 * vy * t;

        pcx += (ti - t) * wx;
        pcy += (ti - t) * wy;
    }
    else {
        pcx += ti * vx;
        pcy += ti * vy;
    }

    double dis = (dist(x2, y2, pcx, pcy)) / v;

    if(dis <= ti)
        return 1;
    return 0;
}

int main() {

    //freopen("ttt", "r", stdin);

    cin >> x1 >> y1 >> x2 >> y2;
    cin >> v >> t;
    cin >> vx >> vy;
    cin >> wx >> wy;

    double cs = 0, cd = 10.0;

    cd = 100000000.0;

    while(cd > cs + eps) {

        double mid = (cs + cd) / 2;

        if(ver(mid))
            cd = mid;
        else
            cs = mid;
    }

    cout << fixed << setprecision(17) << fixed << cd;

    return 0;
}


//ill hit the bottom and escape
#include <bits/stdc++.h>
#define pb push_back
#define pf push_front
#define ppb pop_back
#define ppf pop_front
#define lwb lower_bound
#define upb upper_bound
#define X first
#define Y second
#define int long long
#define double long double
#define slowdown ios :: sync_with_stdio(false)
//#define cin fin
//#define cout fout

using namespace std;

typedef pair<int, int> pii;
typedef complex<double> point;

const double pi = acos(-1);
const int md = 1000 * 1000 * 1000 + 7;
const int o = 1000 * 1000 * 1000;
const int oo = o * o;
const double eps = 1e-9;

point a, b, v, w, smp;
double vm, t;
double x, y;

bool chk(double tim) {
	point p = a;
	p += min(t, tim) * v;
	p += (tim - min(tim, t)) * w;
	return ((double)abs(b - p) / vm < tim + eps );
}

main() {
	slowdown;
	cin.tie(0);

	cin >> x >> y;
	a = point(x, y);
	cin >> x >> y;
	b = point(x, y);
	cin >> vm >> t;
	cin >> x >> y;
	v = point(x, y);
	cin >> x >> y;
	w = point(x, y);
	smp = b - a;

	double f = 0, e = oo + eps;
	double ans = oo;

	for (int i = 0; i < 1000; i++) {
		double mid = (e + f) / 2;
		if (chk(mid))
			e = mid;
		else
			f = mid;
	}

	cout << setprecision(7) << fixed << e << endl;

	return 0;
}


//ill hit the bottom and escape
#include <bits/stdc++.h>
#define pb push_back
#define pf push_front
#define ppb pop_back
#define ppf pop_front
#define lwb lower_bound
#define upb upper_bound
#define X first
#define Y second
#define int long long
#define double long double
#define slowdown ios :: sync_with_stdio(false)
//#define cin fin
//#define cout fout

using namespace std;

typedef pair<int, int> pii;
typedef complex<double> point;

const double pi = acos(-1);
const int md = 1000 * 1000 * 1000 + 7;
const int o = 1000 * 1000 * 1000;
const int oo = o * o;
const double eps = 1e-9;

point a, b, v, w, smp;
double vm, t;
double x, y;

bool chk(double tim) {
	point p = a;
	p += min(t, tim) * v;
	p += (tim - min(tim, t)) * w;
	return ((double)abs(b - p) / vm < tim + eps );
}

main() {
	slowdown;
	cin.tie(0);

	cin >> x >> y;
	a = point(x, y);
	cin >> x >> y;
	b = point(x, y);
	cin >> vm >> t;
	cin >> x >> y;
	v = point(x, y);
	cin >> x >> y;
	w = point(x, y);
	smp = b - a;

	double f = 0, e = 200000 + eps;
	double ans = oo;

	for (int i = 0; i < 300; i++) {
		double mid = (e + f) / 2;
		if (chk(mid))
			e = mid;
		else
			f = mid;
	}

	cout << setprecision(7) << fixed << e << endl;

	return 0;
}


//ill hit the bottom and escape
#include <bits/stdc++.h>
#define pb push_back
#define pf push_front
#define ppb pop_back
#define ppf pop_front
#define lwb lower_bound
#define upb upper_bound
#define X first
#define Y second
#define int long long
#define double long double
#define slowdown ios :: sync_with_stdio(false)
//#define cin fin
//#define cout fout

using namespace std;

typedef pair<int, int> pii;
typedef complex<double> point;

const double pi = acos(-1);
const int md = 1000 * 1000 * 1000 + 7;
const int o = 1000 * 1000 * 1000;
const int oo = o * o;
const double eps = 1e-9;

point a, b, v, w, smp;
double vm, t;
double x, y;

double get2(point smp2) {
	double f = 0, e = 200000 + eps;
	for (int i = 0; i < 1000; i++) {
		double mid = (f + e) / 2;
		if (abs(mid * smp2 - w) > vm)
			e = mid;
		else
			f = mid;
	}

	return 1 / f;
}

double get(double p) {
	double q = sqrt(1 - p * p);
	point v2 = point(p * vm, q * vm);
	v2 += v;
	if (abs(arg(v2) - arg(smp)) <= eps) {
		double t2 = abs(smp) / abs(v2);
		if (abs(t - t2) <= eps || t2 < t)
			return t2;
	}

	point smp2 = smp - v2 * t;

	return get2(smp2) + t;
}

main() {
	slowdown;
	cin.tie(0);

	cin >> x >> y;
	a = point(x, y);
	cin >> x >> y;
	b = point(x, y);
	cin >> vm >> t;
	cin >> x >> y;
	v = point(x, y);
	cin >> x >> y;
	w = point(x, y);
	smp = b - a;

	double f = -1, e = 1 + eps;
	double ans = oo;

	for (int i = 0; i < 300; i++) {
		double tmp = (e - f) / 3;
		double mid1 = f + tmp, mid2 = f + 2 * tmp;
		if (get(mid1) < get(mid2))
			e = mid2;
		else
			f = mid1;
	}

	cout << setprecision(7) << fixed << get(f) << endl;

	return 0;
}


//ill hit the bottom and escape
#include <bits/stdc++.h>
#define pb push_back
#define pf push_front
#define ppb pop_back
#define ppf pop_front
#define lwb lower_bound
#define upb upper_bound
#define X first
#define Y second
#define int long long
#define double long double
#define slowdown ios :: sync_with_stdio(false)
//#define cin fin
//#define cout fout

using namespace std;

typedef pair<int, int> pii;
typedef complex<double> point;

const double pi = acos(-1);
const int md = 1000 * 1000 * 1000 + 7;
const int o = 1000 * 1000 * 1000;
const int oo = o * o;
const double eps = 1e-9;

point a, b, v, w, smp;
double vm, t;
double x, y;

bool chk(double tim) {
	point p = a;
	p += min(t, tim) * v;
	p += (tim - min(tim, t)) * w;
	return ((double)abs(b - p) / vm < tim + eps );
}

main() {
	slowdown;
	cin.tie(0);

	cin >> x >> y;
	a = point(x, y);
	cin >> x >> y;
	b = point(x, y);
	cin >> vm >> t;
	cin >> x >> y;
	v = point(x, y);
	cin >> x >> y;
	w = point(x, y);
	smp = b - a;

	double f = 0, e = 20000 + eps;
	double ans = oo;

	for (int i = 0; i < 300; i++) {
		double mid = (e + f) / 2;
		if (chk(mid))
			e = mid;
		else
			f = mid;
	}

	cout << setprecision(7) << fixed << e << endl;

	return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define INF 1e20
#define eps 1e-8
#define Max 1010

double sx, sy, ex, ey;
    double v, t;
    double vx1, vy1;
    double vx2, vy2;

bool Check(double m){
if(m < t){
    sx = ex - m*vx1;
    sy = ey - m*vy1;
}
else{
    sx = ex - t*vx1 - (m-t)*vx2;
    sy = ey - t*vy1 - (m-t)*vy2;
}
return sx*sx + sy*sy < v*m*v*m;
}

int main() {

    scanf("%lf%lf%lf%lf", &sx, &sy, &ex, &ey);
    scanf("%lf%lf", &v, &t);
    scanf("%lf%lf%lf%lf", &vx1, &vy1, &vx2, &vy2);
    ex -= sx;
    ey -= sy;
    double l=0, r=INF;
    double mid;
    while(r-l>eps){
        mid = (l+r) * 0.5;
        if(Check(mid))r = mid;
        else l = mid;
    }

   printf("%.20f", l) ;

    return 0;
}

/*
#define ll long long
#define Max 500010

const ll mod = 1e9 + 7;
const int INF = 1e6;

pair<int, int> lr[Max];

int main() {

    int n;
    scanf("%d", &n);
    int num[Max];
    for(int i = 0; i < n; i++) {
        scanf("%d", &num[i]);
    }
    int l = 0, r = 0;
    int k = 0;
    for(int i = 1; i < n; i++) {
        if(num[i] == num[i - 1]) {
            l ++;
            r = l;
        } else {
            r ++;
            if(i == n - 1 || num[i + 1] == num[i]) {
                lr[k].first = l;
                lr[k].second = r;
                k ++;
                l = r;
            }
        }
    }

    int ans = 0;
    int now = 0;
    int m = 1;
    for(int i = 0; i < k; i++) {
        r = lr[i].second ;
        l = lr[i].first ;
        m = r - l + 1;
       // cout << m << endl;
        if(m & 1) { //奇数
            for(int i=l; i<=r; i++) {
                num[i] = num[l];
            }
            now = m / 2;
        } else { //偶数
            int i;
            for(i=l; i<=(l+r)/2 ; i++)num[i] = num[l];
            for(; i <=r; i++)num[i] = num[r];
            now = m / 2 - 1;
        }
        ans = max(ans, now);
        m = 1;
    }

cout << ans << endl;
for(int i = 0; i < n; i++)cout << num[i] << ' ';

return 0;
}
*/


#include <bits/stdc++.h>

using namespace std;

#define INF 1e20
#define eps 1e-9
#define Max 1010

double sx, sy, ex, ey;
    double v, t;
    double vx1, vy1;
    double vx2, vy2;

bool Check(double m){
if(m < t){
    sx = ex - m*vx1;
    sy = ey - m*vy1;
}
else{
    sx = ex - t*vx1 - (m-t)*vx2;
    sy = ey - t*vy1 - (m-t)*vy2;
}
return sx*sx + sy*sy < v*m*v*m;
}

int main() {

    scanf("%lf%lf%lf%lf", &sx, &sy, &ex, &ey);
    scanf("%lf%lf", &v, &t);
    scanf("%lf%lf%lf%lf", &vx1, &vy1, &vx2, &vy2);
    ex -= sx;
    ey -= sy;
    double l=0, r=INF;
    double mid;
    while(r-l>eps){
        mid = (l+r) * 0.5;
        if(Check(mid))r = mid;
        else l = mid;
    }

   printf("%.20f", l) ;

    return 0;
}

/*
#define ll long long
#define Max 500010

const ll mod = 1e9 + 7;
const int INF = 1e6;

pair<int, int> lr[Max];

int main() {

    int n;
    scanf("%d", &n);
    int num[Max];
    for(int i = 0; i < n; i++) {
        scanf("%d", &num[i]);
    }
    int l = 0, r = 0;
    int k = 0;
    for(int i = 1; i < n; i++) {
        if(num[i] == num[i - 1]) {
            l ++;
            r = l;
        } else {
            r ++;
            if(i == n - 1 || num[i + 1] == num[i]) {
                lr[k].first = l;
                lr[k].second = r;
                k ++;
                l = r;
            }
        }
    }

    int ans = 0;
    int now = 0;
    int m = 1;
    for(int i = 0; i < k; i++) {
        r = lr[i].second ;
        l = lr[i].first ;
        m = r - l + 1;
       // cout << m << endl;
        if(m & 1) { //奇数
            for(int i=l; i<=r; i++) {
                num[i] = num[l];
            }
            now = m / 2;
        } else { //偶数
            int i;
            for(i=l; i<=(l+r)/2 ; i++)num[i] = num[l];
            for(; i <=r; i++)num[i] = num[r];
            now = m / 2 - 1;
        }
        ans = max(ans, now);
        m = 1;
    }

cout << ans << endl;
for(int i = 0; i < n; i++)cout << num[i] << ' ';

return 0;
}
*/


#include <bits/stdc++.h>
using namespace std;
#define fst first
#define snd second
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
#define pb push_back
#define for_tests(t, tt) int t; scanf("%d", &t); for(int tt = 1; tt <= t; tt++)
template<typename T> inline T abs(T t) { return t < 0? -t : t; }
const ll modn = 1000000007;
inline ll mod(ll x) { return x % modn; }

#define temp template<typename num>
#define ptn point<num>
temp struct point {
	num x, y;
	ptn() {}
	ptn(num a, num b) : x(a), y(b) {}
	template<typename num2> ptn(point<num2> p2) : x(p2.x), y(p2.y) {}
	ptn operator + (ptn o) const { return ptn(x + o.x, y + o.y); }
	ptn operator - (ptn o) const { return ptn(x - o.x, y - o.y); }
	num operator * (ptn o) const { return x * o.x + y * o.y; }
	num operator ^ (ptn o) const { return x * o.y - y * o.x; }
	ptn operator * (num v) const { return ptn(x * v, y * v); }
	ptn operator / (num v) const { return ptn(x / v, y / v); }
	point<double> rotate(double deg) {
		double cs = cos(deg), sn = sin(deg);
		return point<double>(x*cs - y*sn, x*sn + y*cs);
	}
};
typedef point<int> pti;
typedef point<double> ptd;
int t, vm;
pti a, b, v1, v2;
double eps = 1e-10;

ptd get(ptd dir, ptd ve) {
	dir = dir / sqrt(dir * dir);
	double le = 0, ri = 2000;
	while(ri - le > eps) {
		double mi = (le + ri) / 2.;
		ptd x = dir * mi - ve;
		if(x * x <= vm * vm) le = mi;
		else ri = mi;
	}
	ptd x = dir * ((le + ri) / 2) - ve;
	//printf("(%f, %f)\n", x.x, x.y);
	//printf("%f < %d\n",  x * x, vm * vm);
	return dir * ((le + ri) / 2.);
}

double solve(ptd x) {
	ptd z = ptd(b) - x;
	ptd q = get(z, v2);
	return sqrt((z * z) / (q * q)) + t;
}

double try_direct() {
	pti g = b - a;
	ptd p = get(g, v1);
	//printf("%f < %d\n", p * p, vm * vm);
	//printf("%f\n", sqrt(9/2.) - 1);
	//printf("%f\n", 5 - 2*(sqrt(9/2.) - 1));
	//printf("(%f, %f)\n", p.x, p.y);
	//printf("cross %f\n", p ^ ptd(g));
	double vel = p * p;
	if(g * g <= vel * t * t)
		return sqrt((g * g) / vel);
	//printf("not first\n");
	return solve(p * t + ptd(a));
}

int main() {
	scanf("%d %d %d %d", &a.x, &a.y, &b.x, &b.y);
	scanf("%d %d", &vm, &t);
	scanf("%d %d %d %d", &v1.x, &v1.y, &v2.x, &v2.y);
	double st = try_direct();
	double le = -M_PI/2, ri = M_PI/2;
	ptd x = b - a;
	x = x / sqrt(x * x);
	x = x * vm;
	while(ri - le > 1e-8) {
		double ql = le + (ri - le) / 4.,
		       qr = le + 3. * (ri - le) / 4.;
		ptd xl = x.rotate(ql);
		ptd xr = x.rotate(qr);
		double sl = solve(ptd(a) + (xl + ptd(v1)) * t);
		double sr = solve(ptd(a) + (xr + ptd(v1)) * t);
		//printf("(%f -> %f, %f -> %f)\n", ql, sl, qr, sr);
		if(sl < sr) ri = qr;
		else le = ql;
	}
	x = x.rotate((le + ri) / 2.);
	printf("%.15f\n", min(solve(ptd(a) + (x + ptd(v1)) * t), st));
}


#include <bits/stdc++.h>
using namespace std;
#define fst first
#define snd second
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
#define pb push_back
#define for_tests(t, tt) int t; scanf("%d", &t); for(int tt = 1; tt <= t; tt++)
template<typename T> inline T abs(T t) { return t < 0? -t : t; }
const ll modn = 1000000007;
inline ll mod(ll x) { return x % modn; }

#define temp template<typename num>
#define ptn point<num>
temp struct point {
    num x, y;
    ptn() {}
    ptn(num a, num b) : x(a), y(b) {}
    template<typename num2> ptn(point<num2> p2) : x(p2.x), y(p2.y) {}
    ptn operator + (ptn o) const { return ptn(x + o.x, y + o.y); }
    ptn operator - (ptn o) const { return ptn(x - o.x, y - o.y); }
    num operator * (ptn o) const { return x * o.x + y * o.y; }
    num operator ^ (ptn o) const { return x * o.y - y * o.x; }
    ptn operator * (num v) const { return ptn(x * v, y * v); }
    ptn operator / (num v) const { return ptn(x / v, y / v); }
    point<double> rotate(double deg) {
        double cs = cos(deg), sn = sin(deg);
        return point<double>(x*cs - y*sn, x*sn + y*cs);
    }
};
typedef point<int> pti;
typedef point<double> ptd;
int t, vm;
pti a, b, v1, v2;
double eps = 1e-10;
const double pi_ = 3.14159265358979323;

ptd get(ptd dir, ptd ve) {
    dir = dir / sqrt(dir * dir);
    double le = 0, ri = 2000;
    while(ri - le > eps) {
        double mi = (le + ri) / 2.;
        ptd x = dir * mi - ve;
        if(x * x <= vm * vm) le = mi;
        else ri = mi;
    }
    ptd x = dir * ((le + ri) / 2) - ve;
    return dir * ((le + ri) / 2.);
}

double solve(ptd x) {
    ptd z = ptd(b) - x;
    ptd q = get(z, v2);
    return sqrt((z * z) / (q * q)) + t;
}

double try_direct() {
    pti g = b - a;
    ptd p = get(g, v1);
    double vel = p * p;
    if(g * g <= vel * t * t)
        return sqrt((g * g) / vel);
    return solve(p * t + ptd(a));
}

int main() {
    scanf("%d %d %d %d", &a.x, &a.y, &b.x, &b.y);
    scanf("%d %d", &vm, &t);
    scanf("%d %d %d %d", &v1.x, &v1.y, &v2.x, &v2.y);

if(a == b) { puts("0"); return 0; }
    double st = try_direct();
    double le = -pi_/2, ri = pi_/2;
    ptd x = b - a;
    x = x / sqrt(x * x);
    x = x * vm;
    while(ri - le > 1e-8) {
        double ql = le + (ri - le) / 4.,
               qr = le + 3. * (ri - le) / 4.;
        ptd xl = x.rotate(ql);
        ptd xr = x.rotate(qr);
        double sl = solve(ptd(a) + (xl + ptd(v1)) * t);
        double sr = solve(ptd(a) + (xr + ptd(v1)) * t);
        if(sl < sr) ri = qr;
        else le = ql;
    }
    x = x.rotate((le + ri) / 2.);
    printf("%.15f\n", min(solve(ptd(a) + (x + ptd(v1)) * t), st));
}


#include <bits/stdc++.h>
using namespace std;
#define fst first
#define snd second
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
#define pb push_back
#define for_tests(t, tt) int t; scanf("%d", &t); for(int tt = 1; tt <= t; tt++)
template<typename T> inline T abs(T t) { return t < 0? -t : t; }
const ll modn = 1000000007;
inline ll mod(ll x) { return x % modn; }

#define temp template<typename num>
#define ptn point<num>
temp struct point {
	num x, y;
	ptn() {}
	ptn(num a, num b) : x(a), y(b) {}
	template<typename num2> ptn(point<num2> p2) : x(p2.x), y(p2.y) {}
	ptn operator + (ptn o) const { return ptn(x + o.x, y + o.y); }
	ptn operator - (ptn o) const { return ptn(x - o.x, y - o.y); }
	num operator * (ptn o) const { return x * o.x + y * o.y; }
	num operator ^ (ptn o) const { return x * o.y - y * o.x; }
	ptn operator * (num v) const { return ptn(x * v, y * v); }
	ptn operator / (num v) const { return ptn(x / v, y / v); }
	point<double> rotate(double deg) {
		double cs = cos(deg), sn = sin(deg);
		return point<double>(x*cs - y*sn, x*sn + y*cs);
	}
};
typedef point<int> pti;
typedef point<double> ptd;
int t, vm;
pti a, b, v1, v2;
double eps = 1e-10;
const double pi_ = 3.14159265358979323;

ptd get(ptd dir, ptd ve) {
	dir = dir / sqrt(dir * dir);
	double le = 0, ri = 2000;
	while(ri - le > eps) {
		double mi = (le + ri) / 2.;
		ptd x = dir * mi - ve;
		if(x * x <= vm * vm) le = mi;
		else ri = mi;
	}
	ptd x = dir * ((le + ri) / 2) - ve;
	return dir * ((le + ri) / 2.);
}

double solve(ptd x) {
	ptd z = ptd(b) - x;
	ptd q = get(z, v2);
	return sqrt((z * z) / (q * q)) + t;
}

double try_direct() {
	pti g = b - a;
	ptd p = get(g, v1);
	double vel = p * p;
	if(g * g <= vel * t * t)
		return sqrt((g * g) / vel);
	return solve(p * t + ptd(a));
}

int main() {
	scanf("%d %d %d %d", &a.x, &a.y, &b.x, &b.y);
	scanf("%d %d", &vm, &t);
	scanf("%d %d %d %d", &v1.x, &v1.y, &v2.x, &v2.y);
	double st = try_direct();
	double le = -pi_/2, ri = pi_/2;
	ptd x = b - a;
	x = x / sqrt(x * x);
	x = x * vm;
	while(ri - le > 1e-8) {
		double ql = le + (ri - le) / 4.,
		       qr = le + 3. * (ri - le) / 4.;
		ptd xl = x.rotate(ql);
		ptd xr = x.rotate(qr);
		double sl = solve(ptd(a) + (xl + ptd(v1)) * t);
		double sr = solve(ptd(a) + (xr + ptd(v1)) * t);
		if(sl < sr) ri = qr;
		else le = ql;
	}
	x = x.rotate((le + ri) / 2.);
	printf("%.15f\n", min(solve(ptd(a) + (x + ptd(v1)) * t), st));
}


#include <bits/stdc++.h>
using namespace std;
#define fst first
#define snd second
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
#define pb push_back
#define for_tests(t, tt) int t; scanf("%d", &t); for(int tt = 1; tt <= t; tt++)
template<typename T> inline T abs(T t) { return t < 0? -t : t; }
const ll modn = 1000000007;
inline ll mod(ll x) { return x % modn; }

#define temp template<typename num>
#define ptn point<num>
temp struct point {
    num x, y;
    ptn() {}
    ptn(num a, num b) : x(a), y(b) {}
    template<typename num2> ptn(point<num2> p2) : x(p2.x), y(p2.y) {}
    ptn operator + (ptn o) const { return ptn(x + o.x, y + o.y); }
    ptn operator - (ptn o) const { return ptn(x - o.x, y - o.y); }
    num operator * (ptn o) const { return x * o.x + y * o.y; }
    num operator ^ (ptn o) const { return x * o.y - y * o.x; }
    ptn operator * (num v) const { return ptn(x * v, y * v); }
    ptn operator / (num v) const { return ptn(x / v, y / v); }
    point<double> rotate(double deg) {
        double cs = cos(deg), sn = sin(deg);
        return point<double>(x*cs - y*sn, x*sn + y*cs);
    }
};
typedef point<int> pti;
typedef point<double> ptd;
int t, vm;
pti a, b, v1, v2;
double eps = 1e-10;
const double pi_ = 3.14159265358979323;

ptd get(ptd dir, ptd ve) {
    dir = dir / sqrt(dir * dir);
    double le = 0, ri = 2000;
    while(ri - le > eps) {
        double mi = (le + ri) / 2.;
        ptd x = dir * mi - ve;
        if(x * x <= vm * vm) le = mi;
        else ri = mi;
    }
    ptd x = dir * ((le + ri) / 2) - ve;
    return dir * ((le + ri) / 2.);
}

double solve(ptd x) {
    ptd z = ptd(b) - x;
    ptd q = get(z, v2);
    return sqrt((z * z) / (q * q)) + t;
}

double try_direct() {
    pti g = b - a;
    ptd p = get(g, v1);
    double vel = p * p;
    if(g * g <= vel * t * t)
        return sqrt((g * g) / vel);
    return solve(p * t + ptd(a));
}

int main() {
    scanf("%d %d %d %d", &a.x, &a.y, &b.x, &b.y);
    scanf("%d %d", &vm, &t);
    scanf("%d %d %d %d", &v1.x, &v1.y, &v2.x, &v2.y);
    double st = try_direct();
    double le = -pi_/2, ri = pi_/2;

    if(a.x == b.x && a.y == b.y) { puts("0"); return 0; }
    ptd x = b - a;
    x = x / sqrt(x * x);
    x = x * vm;
    while(ri - le > 1e-8) {
        double ql = le + (ri - le) / 4.,
               qr = le + 3. * (ri - le) / 4.;
        ptd xl = x.rotate(ql);
        ptd xr = x.rotate(qr);
        double sl = solve(ptd(a) + (xl + ptd(v1)) * t);
        double sr = solve(ptd(a) + (xr + ptd(v1)) * t);
        if(sl < sr) ri = qr;
        else le = ql;
    }
    x = x.rotate((le + ri) / 2.);
    printf("%.15f\n", min(solve(ptd(a) + (x + ptd(v1)) * t), st));
}