// Create your own template by modifying this file!
#include <string>
#include <vector>
#include <climits>
#include <cstring>
#include <map>
#include <queue>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <set>
#include <unordered_set>
#include <unordered_map>
#include <cassert>
#include <deque>
#include <stack>
#include <functional>
#define MAX(x, a) x = max(x, a)
#define MIN(x, a) x = min(x, a)
#define CASET int ___T, case_n = 1; scanf("%d ", &___T); while (___T-- > 0)
#define SZ(X) ((int)(X).size())
#define LEN(X) strlen(X)
#define FOR(i,c) for(auto &i: c)
#define ALL(x) (x).begin(),(x).end()
#define REP(i,n) for(int i=0;i<(n);i++)
#define REP1(i,a,b) for(int i=(a);i<=(b);i++)
#define REPL(i,x) for(int i=0;x[i];i++)
#define PER(i,n) for(int i=(n)-1;i>=0;i--)
#define PER1(i,a,b) for(int i=(a);i>=(b);i--)
#define GET_4TH(_1, _2, _3, NAME, ...) NAME
#define RI(argv...) GET_4TH(argv, RI3, RI2, RI1)(argv)
#define RI1(x) scanf("%d",&x)
#define RI2(x,y) RI1(x), RI1(y)
#define RI3(x,y,z) RI1(x), RI2(y, z)
#define DRI(argv...) int argv;RI(argv)
#define RS(x) scanf("%s",x)
#define PI(x) printf("%d\n",x)
#define PIS(x) printf("%d ",x)
#define DRL(x) LL x; RL(x)
#ifdef ONLINE_JUDGE
    #define PL(x) printf("%I64d\n",x)
    #define RL(x) scanf("%I64d\n",&x)
#endif
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define BG begin()
#define ED end()
#define PQ priority_queue
#define MS0(x) memset(x,0,sizeof(x))
#define MS1(x) memset(x,-1,sizeof(x))
#define SEP(x) ((x)?'\n':' ')
#define V(x) vector<x>
#define DRA(A, N) VI A(N); REP(i, N) RI(A[i])
using namespace std;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef long long LL;
const int INF = 1000000000;

#ifdef DEBUG
     #define debug(args...)            {dbg,args; cerr<<endl;}
#else
    #define debug(args...)              // Just strip off all debug tokens
#endif

struct debugger
{
    template<typename T> debugger& operator , (const T& v)
    {
        cerr<<v<<" ";
        return *this;
    }
} dbg;

int main()
{
    DRI(x1, y1);
    DRI(x2, y2);
    DRI(vm, t);
    DRI(vx, vy);
    DRI(wx, wy);
    double lb = 0, ub = 1e18;
cout<<y2-y1<<endl;
    REP(k, 100000) {
        double m = lb + (ub - lb) / 2;
        double x, y;
        if (m <= t) {
            x = x2 - vx * m - x1;
            y = y2 - vy * m - y1;
//printf("%f %f %f %f %f\n",m,x,y,lb,ub);
        } else {
            x = x2 - vx * t - wx * (m - t) - x1;
            y = y2 - vy * t - wy * (m - t) - y1;
        }
        double d = sqrt(x * x + y * y);
        if (d / vm <= m) {
            ub = m;
        } else {
            lb = m;
        }

    }
    printf("%.18f\n", lb);
}


// Create your own template by modifying this file!
#include <string>
#include <vector>
#include <climits>
#include <cstring>
#include <map>
#include <queue>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <set>
#include <unordered_set>
#include <unordered_map>
#include <cassert>
#include <deque>
#include <stack>
#include <functional>
#define MAX(x, a) x = max(x, a)
#define MIN(x, a) x = min(x, a)
#define CASET int ___T, case_n = 1; scanf("%d ", &___T); while (___T-- > 0)
#define SZ(X) ((int)(X).size())
#define LEN(X) strlen(X)
#define FOR(i,c) for(auto &i: c)
#define ALL(x) (x).begin(),(x).end()
#define REP(i,n) for(int i=0;i<(n);i++)
#define REP1(i,a,b) for(int i=(a);i<=(b);i++)
#define REPL(i,x) for(int i=0;x[i];i++)
#define PER(i,n) for(int i=(n)-1;i>=0;i--)
#define PER1(i,a,b) for(int i=(a);i>=(b);i--)
#define GET_4TH(_1, _2, _3, NAME, ...) NAME
#define RI(argv...) GET_4TH(argv, RI3, RI2, RI1)(argv)
#define RI1(x) scanf("%d",&x)
#define RI2(x,y) RI1(x), RI1(y)
#define RI3(x,y,z) RI1(x), RI2(y, z)
#define DRI(argv...) int argv;RI(argv)
#define RS(x) scanf("%s",x)
#define PI(x) printf("%d\n",x)
#define PIS(x) printf("%d ",x)
#define DRL(x) LL x; RL(x)
#ifdef ONLINE_JUDGE
    #define PL(x) printf("%I64d\n",x)
    #define RL(x) scanf("%I64d\n",&x)
#endif
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define BG begin()
#define ED end()
#define PQ priority_queue
#define MS0(x) memset(x,0,sizeof(x))
#define MS1(x) memset(x,-1,sizeof(x))
#define SEP(x) ((x)?'\n':' ')
#define V(x) vector<x>
#define DRA(A, N) VI A(N); REP(i, N) RI(A[i])
using namespace std;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef long long LL;
const int INF = 1000000000;

#ifdef DEBUG
     #define debug(args...)            {dbg,args; cerr<<endl;}
#else
    #define debug(args...)              // Just strip off all debug tokens
#endif

struct debugger
{
    template<typename T> debugger& operator , (const T& v)
    {
        cerr<<v<<" ";
        return *this;
    }
} dbg;

int main()
{
    DRI(x1, y1);
    DRI(x2, y2);
    DRI(vm, t);
    DRI(vx, vy);
    DRI(wx, wy);
    double lb = 0, ub = 1e18;
    REP(k, 100000) {
        double m = lb + (ub - lb) / 2;
        double x, y;
        if (m <= t) {
            x = x2 - vx * m - x1;
            y = y2 - vy * m - y1;
//printf("%f %f %f %f %f\n",m,x,y,lb,ub);
        } else {
            x = x2 - vx * t - wx * (m - t) - x1;
            y = y2 - vy * t - wy * (m - t) - y1;
        }
        double d = sqrt(x * x + y * y);
        if (d / vm <= m) {
            ub = m;
        } else {
            lb = m;
        }

    }
    printf("%.18f\n", lb);
}


#pragma comment(linker,"/STACK:102400000,102400000")
#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <limits>
#include <climits>
#include <cstdio>
#include <complex>
#include <numeric>
#include <cassert>
#define endl '\n'
#define mp(x,y) make_pair((x),(y))
#define PI pair<int,int>
#define	PD pair<double,double>
#define PDI pair<double,int>
#define ll long long
#define Fori(x) for(int i=0;i<(x);i++)
#define Forj(x) for(int j=0;j<(x);j++)
#define For1i(x) for(int i=1;i<=(x);i++)
#define For1j(x) for(int j=1;j<=(x);j++)
#define y1 asdfeawf
using namespace std;
const int INF = 2147483647;
const int mod = 1000000007;
const int tmod = 1000000009;
//const double eps= 1e-8;

const double eps = 1e-9;
int sgn(double x)
{
	return x>eps?1:x<-eps?-1:0;
}

double x1,y1,x2,y2;
double v,t;
double wx1,wy1,wx2,wy2;

double fun1(double xx1,double yy1,double xx2,double yy2,double wx,double wy)
{
	double tx = xx2-xx1;
	double ty = yy2-yy1;
	double tmp = sqrt(tx*tx+ty*ty);
	tx/=tmp;
	ty/=tmp;

	double l = -v;
	double r = v;
	while(r-l>1e-7)
	{
		double vx = (r+l)/2;
		double vy = sqrt(v*v-vx*vx);
		double sumx = vx+wx;
		double sumy = vy+wy;
		tmp = sqrt(sumx*sumx+sumy*sumy);
		sumx/=tmp;
		if(sgn(tx-sumx)>0)
			l = vx;
		else
			r = vx;
	}
	double vx = l;
	double vy = sqrt(v*v-vx*vx);
	vx+=wx;
	vy+=wy;
	double vv = sqrt(vx*vx+vy*vy);
	double lenlen = sqrt((xx2-xx1)*(xx2-xx1) + (yy2-yy1)*(yy2-yy1));
	double tm = lenlen/vv;
	return tm;
}

double fun2(double mid)
{
	double vx = mid;
	double vy = sqrt(v*v-vx*vx);
	vx+=wx1;
	vy+=wy1;
	double lenx = vx*t;
	double leny = vy*t;
	double nx1 = x1+lenx;
	double ny1 = y1+leny;
	return t+fun1(nx1,ny1,x2,y2,wx2,wy2);
}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	cin>>x1>>y1>>x2>>y2;
	cin>>v>>t;
	cin>>wx1>>wy1>>wx2>>wy2;
	if(y1>y2)
	{
		y1*=-1;
		y2*=-1;
		wy1*=-1;
		wy2*=-1;
	}
	double ans = 1000000000000LL;
	double fk = fun1(x1,y1,x2,y2,wx1,wy1);
	if(sgn(t-fk)>=0)
		ans = fk;

	double l = -v;
	double r = v;
	while(r-l>1e-9)
	{
		double md = (r-l)/3;
		double lm = l+md;
		double rm = r-md;
		double ans1 = fun2(lm);
		double ans2 = fun2(rm);
		if(sgn(ans2-ans1)>=0)
			r = rm;
		else
			l = lm;
	}
	cout<<fixed<<setprecision(9);
	cout<<min(ans,fun2(l))<<endl;

	return 0;
}


#pragma comment(linker,"/STACK:1024000000,1024000000")
#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <limits>
#include <climits>
#include <cstdio>
#include <complex>
#include <numeric>
#include <cassert>
#define endl '\n'
#define mp(x,y) make_pair((x),(y))
#define PI pair<int,int>
#define	PD pair<double,double>
#define PDI pair<double,int>
#define ll long long
#define Fori(x) for(int i=0;i<(x);i++)
#define Forj(x) for(int j=0;j<(x);j++)
#define For1i(x) for(int i=1;i<=(x);i++)
#define For1j(x) for(int j=1;j<=(x);j++)
#define y1 asdfeawf
using namespace std;
const int INF = 2147483647;
const int mod = 1000000007;
//const double eps= 1e-8;

double x1,y1,x2,y2;
double v,t;
double wx1,wy1;
double wx2,wy2;

const double eps = 1e-7;
int sgn(double x)
{
	return x>eps?1:x<-eps?-1:0;
}

bool check(double mid)
{
	double dx = 0;
	double dy = 0;
	if(sgn(mid-t)==-1)
	{
		dx = mid*wx1;
		dy = mid*wy1;
	}
	else
	{
		dx = t*wx1+(mid-t)*wx2;
		dy = t*wy1+(mid-t)*wy2;
	}
	double tx = dx+x1;
	double ty = dy+y1;
	double len = sqrt((x2-tx)*(x2-tx)+(y2-ty)*(y2-ty));
	double len2 = v*mid;
	if(sgn(len2-len)==-1)
		return false;
	return true;
}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	cin>>x1>>y1>>x2>>y2>>v>>t>>wx1>>wy1>>wx2>>wy2;
	double l = 0;
	double r = 1000000000;
	while(r-l>1e-7)
	{
		double mid = (l+r)/2;
		if(check(mid))
			r = mid;
		else
			l = mid;
	}
	cout<<fixed<<setprecision(7);
	cout<<l<<endl;
	return 0;
}


#pragma comment(linker,"/STACK:102400000,102400000")
#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <limits>
#include <climits>
#include <cstdio>
#include <complex>
#include <numeric>
#include <cassert>
#define endl '\n'
#define mp(x,y) make_pair((x),(y))
#define PI pair<int,int>
#define	PD pair<double,double>
#define PDI pair<double,int>
#define ll long long
#define Fori(x) for(int i=0;i<(x);i++)
#define Forj(x) for(int j=0;j<(x);j++)
#define For1i(x) for(int i=1;i<=(x);i++)
#define For1j(x) for(int j=1;j<=(x);j++)
#define y1 asdfeawf
using namespace std;
const int INF = 2147483647;
const int mod = 1000000007;
const int tmod = 1000000009;
//const double eps= 1e-8;

const double eps = 1e-9;
int sgn(double x)
{
	return x>eps?1:x<-eps?-1:0;
}

const double eps2 = 1e-4;
int sgn2(double x)
{
	return x>eps2?1:x<-eps2?-1:0;
}

double x1,hy1,x2,y2;
double v,t;
double wx1,wy1,wx2,wy2;

double fun1(double xx1,double yy1,double xx2,double yy2,double wx,double wy)
{

	if(sgn(xx1-xx2)>0)
	{
		xx1*=-1;
		xx2*=-1;
		wx*=-1;
	}
	if(sgn(yy1-yy2)>0)
	{
		yy1*=-1;
		yy2*=-1;
		wy*=-1;
	}

	double tx = xx2-xx1;
	double ty = yy2-yy1;
	double tmp = sqrt(tx*tx+ty*ty);
	tx/=tmp;
	ty/=tmp;

	double l = -v;
	double r = v;
	while(r-l>1e-7)
	{
		double vx = (r+l)/2;
		double vy = sqrt(v*v-vx*vx);
		double sumx = vx+wx;
		double sumy = vy+wy;
		if(sgn(sumy)<0)
		{
			r = vx;
			continue;
		}
		tmp = sqrt(sumx*sumx+sumy*sumy);
		sumx/=tmp;
		if(sgn(tx-sumx)>0)
			l = vx;
		else
			r = vx;
	}
	double vx = l;
	double vy = sqrt(v*v-vx*vx);
	vx+=wx;
	vy+=wy;
	if(sgn2(vx*ty-tx*vy)!=0)
	{
		l = -v;
		r = v;
		while(r-l>1e-7)
		{
			double vx = (r+l)/2;
			double vy = -sqrt(v*v-vx*vx);
			double sumx = vx+wx;
			double sumy = vy+wy;
			if(sgn(sumy)<0)
			{
				r = vx;
				continue;
			}
			tmp = sqrt(sumx*sumx+sumy*sumy);
			sumx/=tmp;
			if(sgn(tx-sumx)>0)
				l = vx;
			else
				r = vx;
		}
		vx = l;
		vy = -sqrt(v*v-vx*vx);
		vx+=wx;
		vy+=wy;
	}
	double vv = sqrt(vx*vx+vy*vy);
	double lenlen = sqrt((xx2-xx1)*(xx2-xx1) + (yy2-yy1)*(yy2-yy1));
	double tm = lenlen/vv;
	return tm;
}

double fun2(double mid)
{
	double vx = mid;
	double vy = sqrt(v*v-vx*vx);
	vx+=wx1;
	vy+=wy1;
	double lenx = vx*t;
	double leny = vy*t;
	double nx1 = x1+lenx;
	double ny1 = hy1+leny;
	return t+fun1(nx1,ny1,x2,y2,wx2,wy2);
}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	cin>>x1>>hy1>>x2>>y2;
	cin>>v>>t;
	cin>>wx1>>wy1>>wx2>>wy2;
	if(hy1>y2)
	{
		hy1*=-1;
		y2*=-1;
		wy1*=-1;
		wy2*=-1;
	}
	if(x1>x2)
	{
		x1*=-1;
		x2*=-1;
		wx1*=-1;
		wx2*=-1;
	}
	double ans = 1000000000000LL;
	double fk = fun1(x1,hy1,x2,y2,wx1,wy1);
	if(sgn(t-fk)>=0)
		ans = fk;

	double l = -v;
	double r = v;
	while(r-l>1e-9)
	{
		double md = (r-l)/3;
		double lm = l+md;
		double rm = r-md;
		double ans1 = fun2(lm);
		double ans2 = fun2(rm);
		if(sgn(ans2-ans1)>=0)
			r = rm;
		else
			l = lm;
	}
	cout<<fixed<<setprecision(9);
	cout<<min(ans,fun2(l))<<endl;

	return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <ctype.h>
#include <set>
#include <map>
#include <deque>
#include <unordered_map>
#include <stdio.h>

using namespace std;

typedef long long ll;
typedef std::vector<int> vi;
typedef std::vector<bool> vb;
typedef std::vector<long long> vll;
typedef std::vector<std::vector<int> > vvi;
typedef std::vector<std::pair<int, int> > vpi;
typedef std::pair<int, int> pi;

long long mod=1000000007;

#define all(c) (c).begin(),(c).end()
#define sz(c) (int)(c).size()
#define fo(a, b, c) for(int a = b; a < c; a++)

#define pb push_back
#define mp make_pair

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("input.txt", "rt", stdin);
    freopen("output.txt", "wt", stdout);
    #endif
    long double x1,x2,y1,y2;
    cin>>x1>>y1>>x2>>y2;
    long double vmax, t;
    cin>>vmax>>t;
    long double vx, vy, wx,wy;
    cin>>vx>>vy>>wx>>wy;
    long double ans = 0;
    long double dist = sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
    long double x =x2-x1;
    long double y = y2-y1;
    long double c1 = x*vx+y*vy + sqrt((x*vx + y*vy)*(x*vx + y*vy) + (x*x+y*y)*(vmax*vmax-vx*vx-vy*vy));
    long double c2 = x*wx+y*wy + sqrt((x*wx + y*wy)*(x*wx + y*wy) + (x*x+y*y)*(vmax*vmax-wx*wx-wy*wy));
    c1 /= x*x+y*y;
    c2 /= x*x+y*y;
    if(c1*t >= 1) {
        ans = 1./c1;
        printf("%.10llf", ans);
    }
    else {
        ans = t;
        x -= vx*t;
        y -= vy*t;
        long double sum = sqrt(x*x+y*y);
        //long double sx = vmax * x/sum;
        //long double sy = vmax * y/sum;
        //cout<<sx*sx+sy*sy<<endl;
        //sx+=wx; sy+=wy;
        long double A=vmax*vmax - wx*wx-wy*wy;
        long double B=t*vmax*vmax + x*wx+y*wy;
        long double C = vmax*vmax*t*t - x*x-y*y;
        ans+= (-B + sqrt(B*B - A*C))/A;
        printf("%.10llf", ans);
    }

    //for(int i=0; i<n; i++)

}


#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <ctype.h>
#include <set>
#include <map>
#include <deque>
#include <unordered_map>
#include <stdio.h>

using namespace std;

typedef long long ll;
typedef std::vector<int> vi;
typedef std::vector<bool> vb;
typedef std::vector<long long> vll;
typedef std::vector<std::vector<int> > vvi;
typedef std::vector<std::pair<int, int> > vpi;
typedef std::pair<int, int> pi;

long long mod=1000000007;

#define all(c) (c).begin(),(c).end()
#define sz(c) (int)(c).size()
#define fo(a, b, c) for(int a = b; a < c; a++)

#define pb push_back
#define mp make_pair

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("input.txt", "rt", stdin);
    freopen("output.txt", "wt", stdout);
    #endif
     double x1,x2,y1,y2;
    cin>>x1>>y1>>x2>>y2;
     double vmax, t;
    cin>>vmax>>t;
     double vx, vy, wx,wy;
    cin>>vx>>vy>>wx>>wy;
     double ans = 0;
     double dist = sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
     double x =x2-x1;
     double y = y2-y1;
    if ((x*x<0.5)&&(y*y<0.5)) {
        cout<<0;
        return 0;
    }
     double c1 = x*vx+y*vy + sqrt((x*vx + y*vy)*(x*vx + y*vy) + (x*x+y*y)*(vmax*vmax-vx*vx-vy*vy));
     double c2 = x*wx+y*wy + sqrt((x*wx + y*wy)*(x*wx + y*wy) + (x*x+y*y)*(vmax*vmax-wx*wx-wy*wy));
    c1 /= x*x+y*y;
    c2 /= x*x+y*y;
    if(c1*t >= 1) {
        ans = 1./c1;
        printf("%.10lf", ans);
    }
    else {
        ans = t;
        x -= vx*t;
        y -= vy*t;
         double sum = sqrt(x*x+y*y);
        //long double sx = vmax * x/sum;
        //long double sy = vmax * y/sum;
        //cout<<sx*sx+sy*sy<<endl;
        //sx+=wx; sy+=wy;
         double A=vmax*vmax - wx*wx-wy*wy;
         double B=t*vmax*vmax + x*wx+y*wy;
         double C = vmax*vmax*t*t - x*x-y*y;
        ans+= (-B + sqrt(B*B - A*C))/A;
        printf("%.10lf", ans);
    }

    //for(int i=0; i<n; i++)

}


#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <ctype.h>
#include <set>
#include <map>
#include <deque>
#include <unordered_map>
#include <stdio.h>

using namespace std;

typedef long long ll;
typedef std::vector<int> vi;
typedef std::vector<bool> vb;
typedef std::vector<long long> vll;
typedef std::vector<std::vector<int> > vvi;
typedef std::vector<std::pair<int, int> > vpi;
typedef std::pair<int, int> pi;

long long mod=1000000007;

#define all(c) (c).begin(),(c).end()
#define sz(c) (int)(c).size()
#define fo(a, b, c) for(int a = b; a < c; a++)

#define pb push_back
#define mp make_pair

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("input.txt", "rt", stdin);
    freopen("output.txt", "wt", stdout);
    #endif
    long double x1,x2,y1,y2;
    cin>>x1>>y1>>x2>>y2;
    long double vmax, t;
    cin>>vmax>>t;
    long double vx, vy, wx,wy;
    cin>>vx>>vy>>wx>>wy;
    long double ans = 0;
    long double dist = sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
    long double x =x2-x1;
    long double y = y2-y1;
    if ((x*x<0.5)&&(y*y<0.5)) {
        cout<<0;
        return 0;
    }
    long double c1 = x*vx+y*vy + sqrt((x*vx + y*vy)*(x*vx + y*vy) + (x*x+y*y)*(vmax*vmax-vx*vx-vy*vy));
    long double c2 = x*wx+y*wy + sqrt((x*wx + y*wy)*(x*wx + y*wy) + (x*x+y*y)*(vmax*vmax-wx*wx-wy*wy));
    c1 /= x*x+y*y;
    c2 /= x*x+y*y;
    if(c1*t >= 1) {
        ans = 1./c1;
        printf("%.10llf", ans);
    }
    else {
        ans = t;
        x -= vx*t;
        y -= vy*t;
        long double sum = sqrt(x*x+y*y);
        //long double sx = vmax * x/sum;
        //long double sy = vmax * y/sum;
        //cout<<sx*sx+sy*sy<<endl;
        //sx+=wx; sy+=wy;
        long double A=vmax*vmax - wx*wx-wy*wy;
        long double B=t*vmax*vmax + x*wx+y*wy;
        long double C = vmax*vmax*t*t - x*x-y*y;
        ans+= (-B + sqrt(B*B - A*C))/A;
        printf("%.10llf", ans);
    }

    //for(int i=0; i<n; i++)

}


#include <bits/stdc++.h>
using namespace std;

int main() {
	double x1, y1, x2, y2, vmax, tvento, vx, vy, wx, wy;
	cin >> x1 >> y1 >> x2 >> y2 >> vmax >> tvento >> vx >> vy >> wx >> wy;
	vmax = vmax * vmax;
	double l = 0, r = 1000;
	while(l < r - 1E-6) {
		double x = x1, y = y1, t = (r+l)/2;
		x += min(t, tvento) * vx + max(0.0, t - tvento) * wx;
		y += min(t, tvento) * vy + max(0.0, t - tvento) * wy;
		double velocidade = ((x2 - x) * (x2 - x) + (y2 - y) * (y2 - y))/(t*t);
		//cout << velocidade << " " << t << endl;
		if(velocidade  < vmax) {
			r = t;
		} else {
			l = t;
		}
	}
	printf("%.12f\n", l);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main() {
	double x1, y1, x2, y2, vmax, tvento, vx, vy, wx, wy;
	cin >> x1 >> y1 >> x2 >> y2 >> vmax >> tvento >> vx >> vy >> wx >> wy;
	vmax = vmax * vmax;
	double l = 0, r = 1000000000;
	while(l < r - 1E-6) {
		double x = x1, y = y1, t = (r+l)/2;
		x += min(t, tvento) * vx + max(0.0, t - tvento) * wx;
		y += min(t, tvento) * vy + max(0.0, t - tvento) * wy;
		double velocidade = ((x2 - x) * (x2 - x) + (y2 - y) * (y2 - y))/(t*t);
		//cout << velocidade << " " << t << endl;
		if(velocidade  < vmax) {
			r = t;
		} else {
			l = t;
		}
	}
	printf("%.12f\n", l);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
double xa, ya, xb, yb, vmax, t, vx, vy, wx, wy, xc, yc;
double lo, mid, hi;
inline double distance(double xa, double ya, double xb, double yb) {
  return sqrt(((xa - xb) * (xa - xb)) + ((ya - yb) * (ya - yb)));
}
bool possible(double mid) {
  if(mid > t) {
    xc = xa + (t * vx) + ((mid - t) * wx);
    yc = ya + (t * vy) + ((mid - t) * wy);
  } else {
    xc = xa + (mid * vx);
    yc = ya + (mid * vy);
  }
  return distance(xb, yb, xc, yc) < vmax * mid;
}
int main() {
  scanf("%lf %lf %lf %lf", &xa, &ya, &xb, &yb);
  scanf("%lf %lf %lf %lf %lf %lf", &vmax, &t, &vx, &vy, &wx, &wy);
  lo = 0;
  hi = 10e10;
  while(abs(hi - lo) > 10e-7) {
    mid = (lo + hi) / 2;
    if(possible(mid)) {
      hi = mid;
    } else {
      lo = mid + 10e-7;
    }
  }
  printf("%.18lf\n", lo);
  return 0;
}
// 1509088647750


#include <bits/stdc++.h>
using namespace std;

int main() {
	double x1, y1, x2, y2, vmax, tvento, vx, vy, wx, wy;
	cin >> x1 >> y1 >> x2 >> y2 >> vmax >> tvento >> vx >> vy >> wx >> wy;
	vmax = vmax * vmax;
	double l = 0, r = 1000;
	while(l < r - 1E-6) {
		double x = x1, y = y1, t = (r+l)/2;
		x += min(t, tvento) * vx + max(0.0, t - tvento) * wx;
		y += min(t, tvento) * vy + max(0.0, t - tvento) * wy;
		double velocidade = ((x2 - x) * (x2 - x) + (y2 - y) * (y2 - y))/(t*t);
		//cout << velocidade << " " << t << endl;
		if(velocidade  < vmax) {
			r = t;
		} else {
			l = t;
		}
	}
	printf("%.12f\n", l);
    return 0;
}
// 1508266414096


#include <bits/stdc++.h>
using namespace std;

int main() {
	double x1, y1, x2, y2, vmax, tvento, vx, vy, wx, wy;
	cin >> x1 >> y1 >> x2 >> y2 >> vmax >> tvento >> vx >> vy >> wx >> wy;
	vmax = vmax * vmax;
	double l = 0, r = 1000;
	while(l < r - 1E-6) {
		double x = x1, y = y1, t = (r+l)/2;
		x += min(t, tvento) * vx + max(0.0, t - tvento) * wx;
		y += min(t, tvento) * vy + max(0.0, t - tvento) * wy;
		double velocidade = ((x2 - x) * (x2 - x) + (y2 - y) * (y2 - y))/(t*t);
		//cout << velocidade << " " << t << endl;
		if(velocidade  < vmax) {
			r = t;
		} else {
			l = t;
		}
	}
	printf("%.12f\n", l);
    return 0;
}
// 1508270053555


//Kaori Miyazono, did I reach you ?
#include <bits/stdc++.h>
using namespace std;
typedef long long int lli;

int main(){
	ios::sync_with_stdio(0);cin.tie(0);
	cout << fixed << setprecision(20);
	double x1, y1, x2, y2;
	cin >> x1 >> y1 >> x2 >> y2;
	double v_max, t;
	cin >> v_max >> t;
	double vx, vy, wx, wy;
	cin >> vx >> vy >> wx >> wy;
	double fps = 1e-8;
	double lo = 0, hi = 100, ans = hi;
	double inix = x2 - x1;
	double iniy = y2 - y1;
	while(hi - lo > fps){
		double mid = (lo + hi) / 2;
		double dx = inix - min(t, mid) * vx - max((double) 0, mid - t) * wx;
		double dy = iniy - min(t, mid) * vy - max((double) 0, mid - t) * wy;
		if ( mid <= t ){
			//cout << inix << ' ' << iniy << endl;
			//cout << mid << ' ' << dx << ' ' << dy << endl;
			double kx = dx / mid;
			double ky = dy / mid;
			if ( kx * kx + ky * ky <= v_max * v_max ){
				ans = mid;
				hi = mid;
			}
			else lo = mid;
		}
		else{
			//cout << inix << ' ' << iniy << endl;
			//cout << mid << ' ' << dx << ' ' << dy << endl;
			if ( sqrt(dx * dx + dy * dy) <= v_max * mid){
				ans = mid;
				hi = mid;
			}
			else lo = mid;
		}
		//cout << endl;
	}
	cout << ans << endl;
	return 0;
}
// 1508297212391


//Kaori Miyazono, did I reach you ?
#include <bits/stdc++.h>
using namespace std;
typedef long long int lli;

int main(){
	ios::sync_with_stdio(0);cin.tie(0);
	cout << fixed << setprecision(20);
	double x1, y1, x2, y2;
	cin >> x1 >> y1 >> x2 >> y2;
	double v_max, t;
	cin >> v_max >> t;
	double vx, vy, wx, wy;
	cin >> vx >> vy >> wx >> wy;
	double fps = 1e-8;
	double lo = 0, hi = 100, ans = hi;
	double inix = x2 - x1;
	double iniy = y2 - y1;
	while(hi - lo > fps){
		double mid = (lo + hi) / 2;
		double dx = inix - min(t, mid) * vx - max((double) 0, mid - t) * wx;
		double dy = iniy - min(t, mid) * vy - max((double) 0, mid - t) * wy;
		if ( mid <= t ){
			//cout << inix << ' ' << iniy << endl;
			//cout << mid << ' ' << dx << ' ' << dy << endl;
			double kx = dx / mid;
			double ky = dy / mid;
			if ( kx * kx + ky * ky <= v_max * v_max ){
				ans = mid;
				hi = mid;
			}
			else lo = mid;
		}
		else{
			//cout << inix << ' ' << iniy << endl;
			//cout << mid << ' ' << dx << ' ' << dy << endl;
			if ( sqrt(dx * dx + dy * dy) <= v_max * mid){
				ans = mid;
				hi = mid;
			}
			else lo = mid;
		}
		//cout << endl;
	}
	cout << ans << endl;
	return 0;
}
// 1508293573734


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <random>
#include <chrono>

using namespace std;
using namespace __gnu_pbds;

#define endl '\n'

typedef long long ll;
typedef pair<int, int> pii;
//typedef tree<int,null_type,less<int>,rb_tree_tag, tree_order_statistics_node_update> indexed_set;

const double eps = 1e-9;
double xo, yo, xi, yi, v, t, vx, vy, wx, wy;

double sqr(double x){
	return x * x;
}

bool ok(double T){
	double x = vx * min(T, t) + wx * max(0.0, T - t);
	double y = vy * min(T, t) + wy * max(0.0, T - t);
	return sqr(xi - x) + sqr(yi - y) <= v * v * T * T;
}

int main(){
	ios_base::sync_with_stdio(0);
	cin.tie(0);

	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);

	//mt19937 rng(5);
	//srand(time(0));

	cin >> xo >> yo >> xi >> yi;

	xi -= xo;
	yi -= yo;

	cin >> v >> t;
	cin >> vx >> vy >> wx >> wy;

	double lo = 0.0, hi = 1e16;

	for(int i = 0; i < 111; i++){
		double mid = (lo + hi) / 2.0;
		if(ok(mid))
			hi = mid;
		else
			lo = mid;
	}

	cout << setprecision(10) << fixed;
	cout << lo << endl;

	return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <random>
#include <chrono>

using namespace std;
using namespace __gnu_pbds;

#define endl '\n'

typedef long long ll;
typedef pair<int, int> pii;
//typedef tree<int,null_type,less<int>,rb_tree_tag, tree_order_statistics_node_update> indexed_set;

const double eps = 1e-9;
double xo, yo, xi, yi, v, t, vx, vy, wx, wy;

double sqr(double x){
	return x * x;
}

bool ok(double T){
	double x = vx * min(T, t) + wx * max(0.0, T - t);
	double y = vy * min(T, t) + wy * max(0.0, T - t);
	return sqr(xi - x) + sqr(yi - y) < v * v * T * T + eps;
}

int main(){
	ios_base::sync_with_stdio(0);
	cin.tie(0);

	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);

	//mt19937 rng(5);
	//srand(time(0));

	cin >> xo >> yo >> xi >> yi;

	xi -= xo;
	yi -= yo;

	cin >> v >> t;
	cin >> vx >> vy >> wx >> wy;

	double lo = 0.0, hi = 1e16;

	for(int i = 0; i < 111; i++){
		double mid = (lo + hi) / 2.0;
		if(ok(mid))
			hi = mid;
		else
			lo = mid;
	}

	cout << setprecision(10) << fixed;
	cout << lo << endl;

	return 0;
}


#include <bits/stdc++.h>
using namespace std;
double xa, ya, xb, yb, vmax, t, vx, vy, wx, wy, xc, yc;
double lo, mid, hi;
inline double distance(double xa, double ya, double xb, double yb) {
  return sqrt(((xa - xb) * (xa - xb)) + ((ya - yb) * (ya - yb)));
}
bool possible(double mid) {
  if(mid > t) {
    xc = xa + (t * vx) + ((mid - t) * wx);
    yc = ya + (t * vy) + ((mid - t) * wy);
  } else {
    xc = xa + (mid * vx);
    yc = ya + (mid * vy);
  }
  return distance(xb, yb, xc, yc) < sqrt(vmax * vmax * mid * mid);
}
int main() {
  scanf("%lf %lf %lf %lf", &xa, &ya, &xb, &yb);
  scanf("%lf %lf %lf %lf %lf %lf", &vmax, &t, &vx, &vy, &wx, &wy);
  lo = 0;
  hi = 10e10;
  while(abs(hi - lo) > 10e-7) {
    mid = (lo + hi) / 2;
    if(possible(mid)) {
      hi = mid;
    } else {
      lo = mid + 10e-7;
    }
  }
  printf("%.18lf\n", lo);
  return 0;
}
// 1509088405043


#include <bits/stdc++.h>
using namespace std;
#define fr(i, a, b) for(int i = a, _ = b; i < _; i++)
#define F first
#define S second
typedef pair<int, int> pii;

double sqr(double x){return x*x;}

bool good(double time, double t, int vmax, pii va1, pii va2, pii posi, pii posf){
	double x = posi.F, y = posi.S;
	if(time <= t){
		x += time*va1.F, y += time*va1.S;
	}
	else{
		x += t*va1.F + (time-t)*va2.F;
		y += t*va1.S + (time-t)*va2.S;
	}

	double vx = (posf.F-x)/time, vy = (posf.S-y)/time;
	if(sqr(vx) + sqr(vy) <= sqr(vmax))
		return true;
	else
		return false;
}

int main(){
	pii posi, posf;
	cin >> posi.F >> posi.S >> posf.F >> posf.S;
	int vmax, t;
	cin >> vmax >> t;
	pii va1, va2;
	cin >> va1.F >> va1.S;
	cin >> va2.F >> va2.S;
	double l = 0, r = 1e12, eps = 1e-7, ans = 0;
	while(abs(l-r) >= eps){
		double mid = (l+r)/2;
		if(good(mid, t, vmax, va1, va2, posi, posf)){
			ans = mid;
			r = mid;
		}
		else
			l = mid;
	}

	cout << fixed << setprecision(8) << ans;
	return 0;
}
// 1508334132076


#include<iostream>
#include<cstring>
#include<stack>
#include<vector>
#include<cstdio>
using namespace std;
double x1,y1,x2,y2,v,t,ux,uy,wx,wy,eps=1e-8;
double o=50000000,l=0,r=50000000,cx,cy,m;
bool check(double m)
{
    cx=x1;
    cy=y1;
    if(m-t>eps)
    {
        cx=cx+ux*t+(m-t)*wx;
        cy=cy+uy*t+(m-t)*wy;
    }
    else
    {
        cx=cx+ux*m;
        cy=cy+uy*m;
    }
    if((x2-cx)*(x2-cx)+(y2-cy)*(y2-cy)<=v*v*m*m)return 1;
    return 0;
}
int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin>>x1>>y1>>x2>>y2>>v>>t>>ux>>uy>>wx>>wy;
    while(r-l>eps)
    {
        m=(l+r)/2;
        if(check(m))
        {
            r=m-eps;
            o=m+eps;
        }
        else l=m;
    }
    printf("%.8lf\n",o);
}


#include<iostream>
#include<cstring>
#include<stack>
#include<vector>
#include<cstdio>
using namespace std;
double x1,y1,x2,y2,v,t,ux,uy,wx,wy,eps=1e-8;
double o=50000,l=0,r=50000,cx,cy,m;
bool check(double m)
{
    cx=x1;
    cy=y1;
    if(m-t>eps)
    {
        cx=cx+ux*t+(m-t)*wx;
        cy=cy+uy*t+(m-t)*wy;
    }
    else
    {
        cx=cx+ux*m;
        cy=cy+uy*m;
    }
    if((x2-cx)*(x2-cx)+(y2-cy)*(y2-cy)<=v*v*m*m)return 1;
    return 0;
}
int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin>>x1>>y1>>x2>>y2>>v>>t>>ux>>uy>>wx>>wy;
    while(r-l>eps)
    {
        m=(l+r)/2;
        if(check(m))
        {
            r=m-eps;
            o=m+eps;
        }
        else l=m;
    }
    printf("%.8lf\n",o);
}


#include<iostream>
#include<cstring>
#include<stack>
#include<vector>
#include<cstdio>
using namespace std;
double x1,y1,x2,y2,v,t,ux,uy,wx,wy,eps=1e-8;
double o=50000,l=0,r=50000,cx,cy,m;
bool check(double m)
{
    cx=x1;
    cy=y1;
    if(int(m)>=t)
    {
        cx=cx+ux*t+(m-t)*wx;
        cy=cy+uy*t+(m-t)*wy;
    }
    else
    {
        cx=cx+ux*m;
        cy=cy+uy*m;
    }
    if((x2-cx)*(x2-cx)+(y2-cy)*(y2-cy)<=v*v*m*m)return 1;
    return 0;
}
int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin>>x1>>y1>>x2>>y2>>v>>t>>ux>>uy>>wx>>wy;
    while(r-l>eps)
    {
        m=(l+r)/2;
        if(check(m))
        {
            r=m;
            o=m;
        }
        else l=m;
    }
    printf("%.8lf\n",o);
}


#include<iostream>
#include<cstring>
#include<stack>
#include<vector>
#include<cstdio>
using namespace std;
double x1,y1,x2,y2,v,t,ux,uy,wx,wy,eps=1e-8;
double o=5000000000,l=0,r=5000000000,cx,cy,m;
bool check(double m)
{
    cx=x1;
    cy=y1;
    if(m-t>eps)
    {
        cx=cx+ux*t+(m-t)*wx;
        cy=cy+uy*t+(m-t)*wy;
    }
    else
    {
        cx=cx+ux*m;
        cy=cy+uy*m;
    }
    if((x2-cx)*(x2-cx)+(y2-cy)*(y2-cy)<=v*v*m*m)return 1;
    return 0;
}
int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin>>x1>>y1>>x2>>y2>>v>>t>>ux>>uy>>wx>>wy;
    while(r-l>eps)
    {
        m=(l+r)/2;
        if(check(m))
        {
            r=m-eps;
            o=m+eps;
        }
        else l=m;
    }
    printf("%.8lf\n",o);
}


#include<iostream>
#include<cstring>
#include<stack>
#include<vector>
#include<cstdio>
using namespace std;
double x1,y1,x2,y2,v,t,ux,uy,wx,wy,eps=1e-7;
double o=20000,l=0,r=20000,cx,cy,m;
bool check(double m)
{
    cx=x1;
    cy=y1;
    if(int(m)>=t)
    {
        cx=cx+ux*t+(m-t)*wx;
        cy=cy+uy*t+(m-t)*wy;
    }
    else
    {
        cx=cx+ux*m;
        cy=cy+uy*m;
    }
    if((x2-cx)*(x2-cx)+(y2-cy)*(y2-cy)<=v*v*m*m)return 1;
    return 0;
}
int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin>>x1>>y1>>x2>>y2>>v>>t>>ux>>uy>>wx>>wy;
    while(r-l>eps)
    {
        m=(l+r)/2;
        if(check(m))
        {
            r=m;
            o=m;
        }
        else l=m;
    }
    printf("%.7lf\n",o);
}


#include<iostream>
#include<cstring>
#include<stack>
#include<vector>
#include<cstdio>
using namespace std;
double x1,y1,x2,y2,v,t,ux,uy,wx,wy,eps=1e-8;
double o=50000,l=0,r=50000,cx,cy,m;
bool check(double m)
{
    cx=x1;
    cy=y1;
    if(int(m)>=t)
    {
        cx=cx+ux*t+(m-t)*wx;
        cy=cy+uy*t+(m-t)*wy;
    }
    else
    {
        cx=cx+ux*m;
        cy=cy+uy*m;
    }
    if((x2-cx)*(x2-cx)+(y2-cy)*(y2-cy)<=v*v*m*m)return 1;
    return 0;
}
int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin>>x1>>y1>>x2>>y2>>v>>t>>ux>>uy>>wx>>wy;
    while(r-l>eps)
    {
        m=(l+r)/2;
        if(check(m))
        {
            r=m-eps;
            o=m+eps;
        }
        else l=m;
    }
    printf("%.8lf\n",o);
}


#include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define sz(v) (int)(v).size()
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int N = (int)1e6 + 2015;
const double eps = 1e-7;

struct point {
	double x, y;
	point () {}
	point (double x, double y) : x(x), y(y) {}

} s, f, a, b, c;

double v, t;

bool ok(double T) {
	point res;
	if (t >= T) {
		res.x = a.x * T;
		res.y = a.y * T;
	}
	else {
		res.x = a.x * t + b.x * (T - t);
		res.y = a.y * t + b.y * (T - t);
	}
	point V = point(c.x - res.x, c.y - res.y);

	return sqrt(V.x * V.x + V.y * V.y)  <= v * T - eps;
}

int main (){

	#ifdef LOCAL
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	#endif

	cin >> s.x >> s.y >> f.x >> f.y;
	cin >> v >> t;
	cin >> a.x >> a.y >> b.x >> b.y;

	c = point(f.x - s.x, f.y - s.y);

	double l = 0, r = 1e7;
	for (int i = 0; i < 200; i++)
	{
		double mid = (l + r) / 2;
		if (ok(mid))
			r = mid;
		else
			l = mid;
	}
	printf("%.8f\n", (l + r) / 2);

	return 0;
}


#include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define sz(v) (int)(v).size()
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int N = (int)1e6 + 2015;
const double eps = 1e-10;

struct point {
	double x, y;
	point () {}
	point (double x, double y) : x(x), y(y) {}

} s, f, a, b, c;

double v, t;

bool ok(double T) {
	point res;
	res.x = a.x * t + b.x * (T - t);
	res.y = a.y * t + b.y * (T - t);

	point V = point(c.x - res.x, c.y - res.y);

	return V.x * V.x + V.y * V.y  <= v * v * T * T + eps;
}

int main (){

	#ifdef LOCAL
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	#endif

	cin >> s.x >> s.y >> f.x >> f.y;
	cin >> v >> t;
	cin >> a.x >> a.y >> b.x >> b.y;

	if (s.x == f.x && s.y == f.y)
	{
		puts("0");
		return 0;
	}

	c = point(f.x - s.x, f.y - s.y);
	{
		point res = point(a.x * t, a.y * t);
		point V = point(c.x - res.x, c.y - res.y);

		if (V.x * V.x + V.y * V.y <= v * v * t * t)
		{
			printf("%.8f\n", sqrt(V.x * V.x + V.y * V.y) / v);
			return 0;
		}
	}

	double l = t, r = 1e7;
	for (int i = 0; i < 1000; i++)
	{
		double mid = (l + r) / 2;
		if (ok(mid))
			r = mid;
		else
			l = mid;
	}
	printf("%.8f\n", l);

	return 0;
}


#include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define sz(v) (int)(v).size()
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int N = (int)1e6 + 2015;
const double eps = 1e-10;

struct point {
	double x, y;
	point () {}
	point (double x, double y) : x(x), y(y) {}

} s, f, a, b, c;

double v, t;

bool ok(double T) {
	point res;
	if (T + eps <= t) {
		res.x = a.x * T;
		res.y = a.y * T;
	}
	else {
		res.x = a.x * t + b.x * (T - t);
		res.y = a.y * t + b.y * (T - t);
	}
	point V = point(c.x - res.x, c.y - res.y);

	return V.x * V.x + V.y * V.y  <= v * v * T * T + eps;
}

int main (){

	#ifdef LOCAL
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	#endif

	cin >> s.x >> s.y >> f.x >> f.y;
	cin >> v >> t;
	cin >> a.x >> a.y >> b.x >> b.y;

	if (s.x == f.x && s.y == f.y)
	{
		puts("0");
		return 0;
	}

	c = point(f.x - s.x, f.y - s.y);

	double l = 0, r = 1e9;
	for (int i = 0; i < 1000; i++)
	{
		double mid = (l + r) / 2;
		if (ok(mid))
			r = mid;
		else
			l = mid;
	}
	printf("%.8f\n", l);

	return 0;
}


#include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define sz(v) (int)(v).size()
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int N = (int)1e6 + 2015;
const double eps = 1e-10;

struct point {
	double x, y;
	point () {}
	point (double x, double y) : x(x), y(y) {}

} s, f, a, b, c;

double v, t;

bool ok(double T) {
	point res;
	res.x = a.x * t + b.x * (T - t);
	res.y = a.y * t + b.y * (T - t);

	point V = point(c.x - res.x, c.y - res.y);

	return V.x * V.x + V.y * V.y  <= v * v * T * T + eps;
}

int main (){

	#ifdef LOCAL
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	#endif

	cin >> s.x >> s.y >> f.x >> f.y;
	cin >> v >> t;
	cin >> a.x >> a.y >> b.x >> b.y;

	if (s.x == f.x && s.y == f.y)
	{
		puts("0");
		return 0;
	}

	c = point(f.x - s.x, f.y - s.y);
	{
		point res = point(a.x * t, a.y * t);
		point V = point(c.x - res.x, c.y - res.y);

		if (V.x * V.x + V.y * V.y <= v * v * t * t)
		{
			printf("%.10f\n", sqrt(V.x * V.x + V.y * V.y) / v);
			return 0;
		}
	}

	double l = t, r = 1e7;
	for (int i = 0; i < 1000; i++)
	{
		double mid = (l + r) / 2;
		if (ok(mid))
			r = mid;
		else
			l = mid;
	}
	printf("%.8f\n", r);

	return 0;
}


#include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define sz(v) (int)(v).size()
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int N = (int)1e6 + 2015;
const double eps = 1e-10;

struct point {
	double x, y;
	point () {}
	point (double x, double y) : x(x), y(y) {}

} s, f, a, b, c;

double v, t;

bool ok(double T) {
	point res;
	if (T + eps <= t) {
		res.x = a.x * T;
		res.y = a.y * T;
	}
	else {
		res.x = a.x * t + b.x * (T - t);
		res.y = a.y * t + b.y * (T - t);
	}
	point V = point(c.x - res.x, c.y - res.y);

	return V.x * V.x + V.y * V.y  <= v * v * T * T + eps;
}

int main (){

	#ifdef LOCAL
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	#endif

	cin >> s.x >> s.y >> f.x >> f.y;
	cin >> v >> t;
	cin >> a.x >> a.y >> b.x >> b.y;

	if (s.x == f.x && s.y == f.y)
	{
		puts("0");
		return 0;
	}

	c = point(f.x - s.x, f.y - s.y);

	double l = 0, r = 1e7;
	for (int i = 0; i < 1000; i++)
	{
		double mid = (l + r) / 2;
		if (ok(mid))
			r = mid;
		else
			l = mid;
	}
	printf("%.8f\n", l);

	return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
	ios_base::sync_with_stdio(0); cin.tie(nullptr);

	int x1, y1, x2, y2;
	cin >> x1 >> y1 >> x2 >> y2;

	x2 -= x1;
	y2 -= y1;

	int um, T;
	cin >> um >> T;

	int vx, vy, wx, wy;
	cin >> vx >> vy >> wx >> wy;

	double t = 1;
	while(1)
	{
		double X2 = x2 - (t <= T ? t * vx : T * vx + (t-T) * wx);
		double Y2 = y2 - (t <= T ? t * vy : T * vy + (t-T) * wy);

		if(hypot(X2, Y2) < t * um)
			break;

		t *= 2;
	}

	double t1 = 0;
	double t2 = t;
	while(t2 - t1 > 1e-9 && t2 - t1 > t1 * 1e-9)
	{
		t = (t1 + t2)/2;

		double X2 = x2 - (t <= T ? t * vx : T * vx + (t-T) * wx);
		double Y2 = y2 - (t <= T ? t * vy : T * vy + (t-T) * wy);

		if(hypot(X2, Y2) < t * um)
			t2 = t;
		else
			t1 = t;
	}

	cout.precision(20);
	cout << t1;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
	ios_base::sync_with_stdio(0); cin.tie(nullptr);

	int x1, y1, x2, y2;
	cin >> x1 >> y1 >> x2 >> y2;

	x2 -= x1;
	y2 -= y1;

	int um, T;
	cin >> um >> T;

	int vx, vy, wx, wy;
	cin >> vx >> vy >> wx >> wy;

	double t = 1;
	while(1)
	{
		double X2 = x2 - (t <= T ? t * vx : T * vx + (t-T) * wx);
		double Y2 = y2 - (t <= T ? t * vy : T * vy + (t-T) * wy);

		if(hypot(X2, Y2) < t * um)
			break;

		t *= 2;
	}

	double t1 = 0;
	double t2 = t;
	while(t2 - t1 > 1e-9)
	{
		t = (t1 + t2)/2;

		double X2 = x2 - (t <= T ? t * vx : T * vx + (t-T) * wx);
		double Y2 = y2 - (t <= T ? t * vy : T * vy + (t-T) * wy);

		if(hypot(X2, Y2) < t * um)
			t2 = t;
		else
			t1 = t;
	}

	cout.precision(20);
	cout << t1;
}


#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<cstdlib>
#include<cmath>
#include<cstring>
using namespace std;
#define maxn 10010
#define llg long long
#define eps (double)(0.000000000001)
#define yyj(a) freopen(a".in","r",stdin),freopen(a".out","w",stdout);
llg n,m;
double x1,x2,yy1,y2,nx,ny,ans,v,t,mid;
double X,Y;
double check(double x)
{
	double sumx=X,sumy=Y;
	sumx+=min(x,t)*x1;
	sumy+=min(x,t)*yy1;
	if (x>t)
	{
		sumx+=(x-t)*x2;
		sumy+=(x-t)*y2;
	}
	return sqrt(abs(sumx-nx)*abs(sumx-nx)+abs(sumy-ny)*abs(sumy-ny))/x;
}

int main()
{
//	yyj("B");
	cin>>X>>Y>>nx>>ny;
	cin>>v>>t;
	double l=0,r=1000000000;
	cin>>x1>>yy1;
	cin>>x2>>y2;
	while (l<r)
	{
		mid=(l+r)/2;
		if (check(mid)<=v) {ans=mid; r=mid-eps;} else l=mid+eps;
	}
	printf("%.18lf",ans);
	return 0;
}


#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<cstdlib>
#include<cmath>
#include<cstring>
using namespace std;
#define maxn 10010
#define llg long long
#define eps (double)(0.00000001)
#define yyj(a) freopen(a".in","r",stdin),freopen(a".out","w",stdout);
llg n,m;
double x1,x2,yy1,y2,nx,ny,ans,v,t,mid;
double X,Y;
double check(double x)
{
	double sumx=X,sumy=Y;
	sumx+=min(x,t)*x1;
	sumy+=min(x,t)*yy1;
	if (x>t)
	{
		sumx+=(x-t)*x2;
		sumy+=(x-t)*y2;
	}
	return sqrt(abs(sumx-nx)*abs(sumx-nx)+abs(sumy-ny)*abs(sumy-ny))/x;
}

int main()
{
	//yyj("B");
	cin>>X>>Y>>nx>>ny;
	cin>>v>>t;
	double l=0,r=1000000000;
	cin>>x1>>yy1;
	cin>>x2>>y2;
	while (r-l>eps)
	{
		mid=(l+r)/2;
		if (check(mid)<=v) {ans=mid; r=mid-eps;} else l=mid+eps;
	}
	printf("%.18lf",ans);
	return 0;
}


n, q = input().split()
n = int(n)
q = int(q)

M = [[0 for x in range(n + 5)] for y in range(4)]
incov = 0

for rep in range(q):
    x, y = input().split()
    x = int(x)
    y = int(y)

    # verific sus si jos
    if x == 1:
        if M[2][y] == 1:
            if M[x][y] == 1: #scot
                incov = incov - 1
            else: #pun
                incov = incov + 1
    else:
        if M[1][y] == 1:
            if M[x][y] == 1: #scot
                incov = incov - 1
            else: #pun
                incov = incov + 1

    #verific pe diag in stanga
    if x == 1:
        if M[2][y - 1] == 1:
            if M[x][y] == 1: #scot
                incov = incov - 1
            else: #pun
                incov = incov + 1
    else:
        if M[1][y - 1] == 1:
            if M[x][y] == 1: #scot
                incov = incov - 1
            else: #pun
                incov = incov + 1

    #verific pe diag in dreapta
    if x == 1:
        if M[2][y + 1] == 1:
            if M[x][y] == 1: #scot
                incov = incov - 1
            else: #pun
                incov = incov + 1
    else:
        if M[1][y + 1] == 1:
            if M[x][y] == 1: #scot
                incov = incov - 1
            else: #pun
                incov = incov + 1

    M[x][y] = 1 - M[x][y]

    if incov == 0:
        print("Yes")
    else:
        print("No")


n, q = input().split()
n = int(n)
q = int(q)

M = [[0 for x in range(n + 1)] for y in range(3)]
incov = 0

for rep in range(q):
    x, y = input().split()
    x = int(x)
    y = int(y)

    # verific sus si jos
    if x == 1:
        if M[2][y] == 1:
            if M[x][y] == 1: #scot
                incov = incov - 1
            else: #pun
                incov = incov + 1
    else:
        if M[1][y] == 1:
            if M[x][y] == 1: #scot
                incov = incov - 1
            else: #pun
                incov = incov + 1

    #verific pe diag in stanga
    if x == 1:
        if M[2][y - 1] == 1:
            if M[x][y] == 1: #scot
                incov = incov - 1
            else: #pun
                incov = incov + 1
    else:
        if M[1][y - 1] == 1:
            if M[x][y] == 1: #scot
                incov = incov - 1
            else: #pun
                incov = incov + 1

    #verific pe diag in dreapta
    if x == 1:
        if M[2][y + 1] == 1:
            if M[x][y] == 1: #scot
                incov = incov - 1
            else: #pun
                incov = incov + 1
    else:
        if M[1][y + 1] == 1:
            if M[x][y] == 1: #scot
                incov = incov - 1
            else: #pun
                incov = incov + 1

    M[x][y] = 1 - M[x][y]

    if incov == 0:
        print("Yes")
    else:
        print("No")


n, q = map(int, input().split())
a = [[0, 0] for i in range(n + 2)]
w = 0

z = [list(map(int, input().split())) for i in range(q)]
for i in range(q):
    r, c = z[i]
    r -= 1
    if a[c][r] == 1:
        a[c][r] = 0
        s = 0
        for j in range(3):
            if a[c - 1 + j][(r + 1) % 2] == 1:
                s += 1
        w -= s
    else:
        a[c][r] = 1
        s = 0
        for j in range(3):
            if a[c - 1 + j][(r + 1) % 2] == 1:
                s += 1
        w += s
    if w == 0:
        print("Yes")
    else:
        print("No")


from collections import defaultdict as dc
n,q=map(int,input().split())
c=0
x=dc(int)
y=dc(int)
for _ in range(q):
    a,b=map(int,input().split())
    if a==1:
        if x[b]==0:
            x[b]=1
            for i in range(-1,2):
                if b+i>=1 and b+i<=n and y[b+i]==1:
                    c+=1
        else:
            x[b]=0
            for i in range(-1,2):
                if b+i>=1 and b+i<=n and y[b+i]==1:
                    c-=1
    else:
        if y[b]==0:
            y[b]=1
            for i in range(-1,2):
                if b+i>=1 and b+i<=n and x[b+i]==1:
                    c+=1
        else:
            y[b]=0
            for i in range(-1,2):
                if b+i>=1 and b+i<=n and x[b+i]==1:
                    c-=1
    #print(t,a,b,c,x, y)
    if y[n]==1:
        print("No")
    else:
        if c==0:
            print("Yes")
        else:
            print("No")


from collections import defaultdict as dc
n,q=map(int,input().split())
c=0
l=[[0 for i in range(n+1)]for j in range(3)]
for _ in range(q):
    a,b=map(int,input().split())
    x=1 if l[a][b]==0 else -1
    l[a][b]=1-l[a][b]
    if a==1:
        t=2
    else:
        t=1
    for i in range(-1,2):
        if b+i>0 and b+i<=n and l[t][b+i]==1:
            c+=x
    if c==0:
        print("Yes")
    else:
        print("No")


from collections import defaultdict as dc
n,q=map(int,input().split())
c=0
x=dc(int)
y=dc(int)
for _ in range(q):
    a,b=map(int,input().split())
    if a==1:
        if x[b]==0:
            x[b]=1
            for i in range(-1,2):
                if b+i>=1 and b+i<=n and y[b+i]==1:
                    c+=1
        else:
            x[b]=0
            for i in range(-1,2):
                if b+i>=1 and b+i<=n and y[b+i]==1:
                    c-=1
    else:
        if y[b]==0:
            y[b]=1
            for i in range(-1,2):
                if b+i>=1 and b+i<=n and x[b+i]==1:
                    c+=1
        else:
            y[b]=0
            for i in range(-1,2):
                if b+i>=1 and b+i<=n and x[b+i]==1:
                    c-=1
    #print(t,a,b,c,x, y)
    if c==0:
        print("Yes")
    else:
        print("No")


from collections import defaultdict as dc
n,q=map(int,input().split())
l=0
r=0
x=dc(int)
y=dc(int)
for _ in range(q):
    a,b=map(int,input().split())
    if a==1:
        if x[b]==0:
            x[b]=1
            l+=1
        else:
            x[b]=0
            l-=1
    else:
        if y[b]==0:
            y[b]=1
            r+=1
        else:
            y[b]=0
            r-=1
    if l==0 or r==0:
        print("Yes")
    else:
        print("No")


from collections import defaultdict as dc
n,q=map(int,input().split())
c=0
x=dc(int)
y=dc(int)
for i in range(q):
    a,b=map(int,input().split())
    if a==1:
        if x[b]==0:
            x[b]=1
            if y[b]==1 or (b+1<=n and y[b+1]==1) or (b-1>=1 and y[b-1]==1):
                c+=1
        else:
            x[b]=0
            if y[b]==1 or (b+1<=n and y[b+1]==1) or (b-1>=1 and y[b-1]==1):
                c-=1
    else:
        if y[b]==0:
            y[b]=1
            if x[b]==1 or (b+1<=n and x[b+1]==1) or (b-1>=1 and x[b-1]==1):
                c+=1
        else:
            y[b]=0
            if x[b]==1 or (b+1<=n and x[b+1]==1) or (b-1>=1 and x[b-1]==1):
                c-=1
    #print(i,a,b,l,x,r,y)
    if c==0:
        print("Yes")
    else:
        print("No")


sp = lambda: list(map(int, input().split()))
si = lambda: int(input())

n, q = sp()

blockages = set()
# made like coordinates (a,b)

cells1 = set()
cells2 = set()
cells = (cells1, cells2)

for QUERY in range(q):
    r, c = sp()
    r-=1  # shift coordinates
    if c in cells[r]:
        cells[r].remove(c)
    else:
        cells[r].add(c)

    for c2 in range(c-1, c+2):
        if c not in cells[r]:
            if r==0:
                blockages.discard((c,c2))
            else:
                blockages.discard((c2,c))
        else:
            if c2 in cells[1-r]:
                if r==0:
                    blockages.add((c,c2))
                else:
                    blockages.add((c2,c))

    print(("No", "Yes")[len(blockages) == 0])


sp = lambda: list(map(int, input().split()))
si = lambda: int(input())

n, q = sp()

blockages = set()
# made like coordinates (a,b)

cells1 = set()
cells2 = set()
cells = (cells1, cells2)

l = []

for QUERY in range(q):
    r, c = sp()
    r-=1  # shift coordinates
    if c in cells[r]:
        cells[r].remove(c)
    else:
        cells[r].add(c)

    for c2 in range(c-1, c+2):
        if c not in cells[r]:
            if r==0:
                blockages.discard((c,c2))
            else:
                blockages.discard((c2,c))
        else:
            if c2 in cells[1-r]:
                if r==0:
                    blockages.add((c,c2))
                else:
                    blockages.add((c2,c))

    l.append(("No", "Yes")[len(blockages) == 0])

print("\n".join(l))


#from bisect import bisect_left as bl                #c++ lowerbound bl(array,element)
#from bisect import bisect_right as br               #c++ upperbound br(array,element)
#from __future__ import print_function, division    #while using python2

def modinv(n,p):
	return pow(n,p-2,p)

def main():
	#sys.stdin = open('input.txt', 'r')
	#sys.stdout = open('output.txt', 'w')

	n, q =[int(x) for x in input().split()]
	walls = set()
	flipped = set()

	for i in range(q):
		y, x = [int(x) for x in input().split()]
		key = str(y) + '-' + str(x)
		if key not in flipped:
			flipped.add(key)
			for dx in range(-1, 2):
				for dy in range(-1, 2):
					xn = x+dx
					yn = y+dy
					if 1 <= xn <= n and 1 <= yn <= 2 and ([yn, xn] not in [[1, 1], [2, n], [y, x]]):
						key2 = str(yn) + '-' + str(xn)
						if key2 in flipped:
							temp = [key, key2]
							temp.sort()
							walls.add(temp[0] + '-' + temp[1])
		else:
			flipped.remove(key)
			for dx in range(-1, 2):
				for dy in range(-1, 2):
					xn = x+dx
					yn = y+dy
					if 1 <= xn <= n and 1 <= yn <= 2 and ([yn, xn] not in [[1, 1], [2, n], [y, x]]):
						key2 = str(yn) + '-' + str(xn)
						if key2 in flipped:
							temp = [key, key2]
							temp.sort()
							walls.remove(temp[0] + '-' + temp[1])
		if len(walls) > 0:
			print("No")
		else:
			print("Yes")

#------------------ Python 2 and 3 footer by Pajenegod and c1729-----------------------------------------
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange

import os, sys
from io import IOBase, BytesIO

BUFSIZE = 8192
class FastIO(BytesIO):
	newlines = 0
	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = "x" in file.mode or "w" in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
		return s
	def read(self):
		while self._fill(): pass
		return super(FastIO,self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill(); self.newlines = s.count(b"\n") + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			self.truncate(0), self.seek(0)

class IOWrapper(IOBase):
	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s:self.buffer.write(s.encode('ascii'))
			self.read = lambda:self.buffer.read().decode('ascii')
			self.readline = lambda:self.buffer.readline().decode('ascii')

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')

if __name__ == '__main__':
   main()


#from bisect import bisect_left as bl                #c++ lowerbound bl(array,element)
#from bisect import bisect_right as br               #c++ upperbound br(array,element)
#from __future__ import print_function, division    #while using python2

def modinv(n,p):
	return pow(n,p-2,p)

def main():
	#sys.stdin = open('input.txt', 'r')
	#sys.stdout = open('output.txt', 'w')

	n, q =[int(x) for x in input().split()]
	walls = set()
	flipped = set()

	queries = []
	for i in range(q):
		queries.append([int(x) for x in input().split()])

	for q in queries:
		y, x = q
		key = str(y) + '-' + str(x)
		if key not in flipped:
			flipped.add(key)
			neighbours = []
			if y == 1:
				neighbours.append([2, x-1])
				neighbours.append([2, x])
				neighbours.append([2, x+1])
			else:
				neighbours.append([1, x-1])
				neighbours.append([1, x])
				neighbours.append([1, x+1])

			for yx in neighbours:
				yn, xn = yx
				if 1 <= xn <= n and 1 <= yn <= 2 and ([yn, xn] not in [[1, 1], [2, n]]):
					key2 = str(yn) + '-' + str(xn)
					if key2 in flipped:
						temp = [key, key2]
						temp.sort()
						walls.add(temp[0] + '-' + temp[1])
		else:
			flipped.remove(key)
			neighbours = []
			if y == 1:
				neighbours.append([2, x-1])
				neighbours.append([2, x])
				neighbours.append([2, x+1])
			else:
				neighbours.append([1, x-1])
				neighbours.append([1, x])
				neighbours.append([1, x+1])

			for yx in neighbours:
				yn, xn = yx
				if 1 <= xn <= n and 1 <= yn <= 2 and ([yn, xn] not in [[1, 1], [2, n]]):
					key2 = str(yn) + '-' + str(xn)
					if key2 in flipped:
						temp = [key, key2]
						temp.sort()
						walls.remove(temp[0] + '-' + temp[1])

		# print(flipped)
		# print(walls)
		# input()

		if len(walls) > 0:
			print("No")
		else:
			print("Yes")

#------------------ Python 2 and 3 footer by Pajenegod and c1729-----------------------------------------
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange

import os, sys
from io import IOBase, BytesIO

BUFSIZE = 8192
class FastIO(BytesIO):
	newlines = 0
	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = "x" in file.mode or "w" in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
		return s
	def read(self):
		while self._fill(): pass
		return super(FastIO,self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill(); self.newlines = s.count(b"\n") + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			self.truncate(0), self.seek(0)

class IOWrapper(IOBase):
	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s:self.buffer.write(s.encode('ascii'))
			self.read = lambda:self.buffer.read().decode('ascii')
			self.readline = lambda:self.buffer.readline().decode('ascii')

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')

if __name__ == '__main__':
   main()


n, q = [int(i) for i in input().split(" ")]
m = [[0, 0] for i in range(n+2)]
zle = 0
for i in range(q):
    x, y = [int(i) for i in input().split(" ")]
    x -= 1
    if m[y][x] == 0:
        m[y][x] = 1
        val1 = m[y+1][1-x]+m[y][x]
        val2 = m[y][1-x]+m[y][x]
        val3 = m[y-1][1-x]+m[y][x]
        #print(val1, val2, val3)
        if val1 == 2: zle += 1
        if val2 == 2: zle += 1
        if val3 == 2: zle += 1
    else:
        val1 = m[y+1][1-x]+m[y][x]
        val2 = m[y][1-x]+m[y][x]
        val3 = m[y-1][1-x]+m[y][x]
        #print(val1, val2, val3)
        if val1 == 2: zle -= 1
        if val2 == 2: zle -= 1
        if val3 == 2: zle -= 1
        m[y][x] = 0
    #print(zle)
    if zle > 0: print("NO")
    else: print("YES")


n, q = [int(i) for i in input().split(" ")]
m = [[0, 0] for i in range(n+2)]
ans = []
zle = 0
for i in range(q):
    x, y = [int(i) for i in input().split(" ")]
    x -= 1
    if m[y][x] == 0:
        m[y][x] = 1
        val1 = m[y+1][1-x]+m[y][x]
        val2 = m[y][1-x]+m[y][x]
        val3 = m[y-1][1-x]+m[y][x]
        #print(val1, val2, val3)
        if val1 == 2: zle += 1
        if val2 == 2: zle += 1
        if val3 == 2: zle += 1
    else:
        val1 = m[y+1][1-x]+m[y][x]
        val2 = m[y][1-x]+m[y][x]
        val3 = m[y-1][1-x]+m[y][x]
        #print(val1, val2, val3)
        if val1 == 2: zle -= 1
        if val2 == 2: zle -= 1
        if val3 == 2: zle -= 1
        m[y][x] = 0
    #print(zle)
    if zle > 0: ans.append("NO")
    else: ans.append("YES")
print(str(ans)[2:-2].replace("\', \'", "\n"))


#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
    sys.stdin = open('input.txt', 'r')
    sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz/'
M=998244353
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]

#-------------------------code---------------------------#
# vsInput()

n,q=value()
have=set()

problem=[ [set() for i in range(n)] for j in range(2) ]
a=[ [0 for i in range(n)] for j in range(2) ]
tot=0

for i in range(q):
    x,y=value()
    x-=1
    y-=1

    if(a[x][y]):

        tot-=len(problem[x][y])
        problem[x][y].clear()

        if(a[x^1][y]):
            problem[x^1][y].remove(y)
            tot-=1
        if(y>0 and a[x^1][y-1]):
            problem[x^1][y-1].remove(y)
            tot-=1
        if(y<n-1 and a[x^1][y+1]):
            problem[x^1][y+1].remove(y)
            tot-=1

    else:

        if(a[x^1][y]):
            problem[x^1][y].add(y)
            problem[x][y].add(y)
            tot+=1
        if(y>0 and a[x^1][y-1]):
            problem[x^1][y-1].add(y)
            problem[x][y].add(y-1)
            tot+=1
        if(y<n-1 and a[x^1][y+1]):
            problem[x^1][y+1].add(y)
            problem[x][y].add(y-1)
            tot+=1

        tot+=len(problem[x][y])

    a[x][y]^=1

    if(tot): print("No")
    else: print("Yes")


#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
    sys.stdin = open('input.txt', 'r')
    sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz/'
M=998244353
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]

#-------------------------code---------------------------#
# vsInput()

n,q=value()
have=set()

problem=[ [set() for i in range(n)] for j in range(2) ]
a=[ [0 for i in range(n)] for j in range(2) ]
tot=0

for i in range(q):
    x,y=value()
    x-=1
    y-=1

    if(a[x][y]):

        tot-=len(problem[x][y])
        problem[x][y].clear()

        if(a[x^1][y]):
            problem[x^1][y].remove(y)
            tot-=1
        if(y>0 and a[x^1][y-1]):
            problem[x^1][y-1].remove(y)
            tot-=1
        if(y<n-1 and a[x^1][y+1]):
            problem[x^1][y+1].remove(y)
            tot-=1

    else:

        if(a[x^1][y]):
            problem[x^1][y].add(y)
            problem[x][y].add(y)
            tot+=1
        if(y>0 and a[x^1][y-1]):
            problem[x^1][y-1].add(y)
            problem[x][y].add(y-1)
            tot+=1
        if(y<n-1 and a[x^1][y+1]):
            problem[x^1][y+1].add(y)
            problem[x][y].add(y+1)
            tot+=1

        tot+=len(problem[x][y])

    a[x][y]^=1

    if(tot): print("No")
    else: print("Yes")


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__

blocks={}

lavablocks={}
def newlava():
    for _ in range(q):
        r,c = [int(x) for x in input().split()]
        getlavablocks=blocks.get((r,c),False)
        if r==1:
            newposx=2
        else:
            newposx=1
        lavprev=blocks.get((newposx,c-1),False)
        lavcur=blocks.get((newposx,c),False)
        lavnext=blocks.get((newposx,c+1),False)
        if getlavablocks:
            del blocks[(r,c)]
            freq=lavablocks.get((r,c),0)
            if freq:
                if freq==1:
                    del lavablocks[(r,c)]
                else:
                    lavablocks[(r,c)]=freq-1
            freq=lavablocks.get((newposx,c-1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c-1)]
                else:
                    lavablocks[(newposx,c-1)]=freq-1
            freq=lavablocks.get((newposx,c),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c)]
                else:
                    lavablocks[(newposx,c)]=freq-1
            freq=lavablocks.get((newposx,c+1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c+1)]
                else:
                    lavablocks[(newposx,c+1)]=freq-1

        else:
            blocks[(r,c)]=True

            if lavprev:
                freq=lavablocks.get((newposx,c-1),0)
                lavablocks[(newposx,c-1)]=freq+1
                freq=lavablocks.get((r,c),0)
                lavablocks[(r,c)]=freq+1
            if lavcur:
                freq=lavablocks.get((newposx,c),0)
                lavablocks[(newposx,c)]=freq+1
                freq=lavablocks.get((r,c),0)
                lavablocks[(r,c)]=freq+1
            if lavnext:
                freq=lavablocks.get((newposx,c+1),0)
                lavablocks[(newposx,c+1)]=freq+1
                freq=lavablocks.get((r,c),0)
                lavablocks[(r,c)]=freq+1
        #print(len(lavablocks))
        if len(lavablocks)==1:
            lavablocks.clear()
        if lavablocks:
            yield 'No'
        else:
            yield 'Yes'
        print(blocks,lavablocks)

if __name__ == '__main__':
    t,q= [int(x) for x in input().split()]
    ans = newlava()
    print(*ans,sep='\n')


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__

blocks={}

lavablocks={}
def newlava():
    for _ in range(q):
        r,c = [int(x) for x in input().split()]
        getlavablocks=blocks.get((r,c),False)
        if r==1:
            newposx=2
        else:
            newposx=1
        lavprev=blocks.get((newposx,c-1),False)
        lavcur=blocks.get((newposx,c),False)
        lavnext=blocks.get((newposx,c+1),False)
        if getlavablocks:
            del blocks[(r,c)]
            freq=lavablocks.get((r,c),0)
            if freq:
                if freq==1:
                    del lavablocks[(r,c)]
                else:
                    lavablocks[(r,c)]=freq-1
            freq=lavablocks.get((newposx,c-1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c-1)]
                else:
                    lavablocks[(newposx,c-1)]=freq-1
            freq=lavablocks.get((newposx,c),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c)]
                else:
                    lavablocks[(newposx,c)]=freq-1
            freq=lavablocks.get((newposx,c+1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c+1)]
                else:
                    lavablocks[(newposx,c+1)]=freq-1

        else:
            blocks[(r,c)]=True
            if lavprev:
                freq=lavablocks.get((newposx,c-1),0)
                lavablocks[(newposx,c-1)]=freq+1
            elif lavcur:
                freq=lavablocks.get((newposx,c),0)
                lavablocks[(newposx,c)]=freq+1
            elif lavnext:
                freq=lavablocks.get((newposx,c+1),0)
                lavablocks[(newposx,c+1)]=freq+1
        if lavablocks:
            yield 'No'
        else:
            yield 'Yes'
        #print(blocks,lavablocks)

if __name__ == '__main__':
    t,q= [int(x) for x in input().split()]
    ans = newlava()
    print(*ans,sep='\n')


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__

blocks={}

lavablocks={}
def newlava():
    for _ in range(q):
        r,c = [int(x) for x in input().split()]
        getlavablocks=blocks.get((r,c),False)
        if r==1:
            newposx=2
        else:
            newposx=1
        lavprev=blocks.get((newposx,c-1),False)
        lavcur=blocks.get((newposx,c),False)
        lavnext=blocks.get((newposx,c+1),False)
        if getlavablocks:
            del blocks[(r,c)]
            freq=lavablocks.get((r,c),0)
            if freq:
                if freq==1:
                    del lavablocks[(r,c)]
                else:
                    lavablocks[(r,c)]=freq-1
            freq=lavablocks.get((newposx,c-1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c-1)]
                else:
                    lavablocks[(newposx,c-1)]=freq-1
            freq=lavablocks.get((newposx,c),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c)]
                else:
                    lavablocks[(newposx,c)]=freq-1
            freq=lavablocks.get((newposx,c+1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c+1)]
                else:
                    lavablocks[(newposx,c+1)]=freq-1

        else:
            blocks[(r,c)]=True

            if lavprev:
                freq=lavablocks.get((newposx,c-1),0)
                lavablocks[(newposx,c-1)]=freq+1
                lavablocks[(r,c)]=1
            elif lavcur:
                freq=lavablocks.get((newposx,c),0)
                lavablocks[(newposx,c)]=freq+1
                lavablocks[(r,c)]=1
            elif lavnext:
                freq=lavablocks.get((newposx,c+1),0)
                lavablocks[(newposx,c+1)]=freq+1
                lavablocks[(r,c)]=1
        if lavablocks:
            yield 'No'
        else:
            yield 'Yes'
        #print(blocks,lavablocks)

if __name__ == '__main__':
    t,q= [int(x) for x in input().split()]
    ans = newlava()
    print(*ans,sep='\n')


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
blocked={}
found=False
lavablock={}
def lava():
    for _ in range(q):
        r,c = [int(x) for x in input().split()]
        getlava=blocked.get((r,c),False)
        getlavablocks=lavablock.get((r,c),False)
        if getlava:
            del blocked[(r,c)]
            if getlavablocks:
                del lavablock[(r,c)]
        else:
            blocked[(r,c)]=True
        #print(blocked)
        if not lavablock:
            for lav in blocked:
                posx,posy=lav
                if posx==1:
                    newposx=2
                else:
                    newposx=1
                lavprev=blocked.get((newposx,posy-1),False)
                lavcur=blocked.get((newposx,posy),False)
                lavnext=blocked.get((newposx,posy+1),False)
                if lavprev:

                    lavablock[(newposx,posy-1)]=True
                    break
                elif lavcur:

                    lavablock[(newposx,posy)]=True
                    break
                elif lavnext:

                    lavablock[(newposx,posy+1)]=True
                    break
        if lavablock:
            yield "No"
        else:
            yield "Yes"

if __name__ == '__main__':
    t,q= [int(x) for x in input().split()]
    ans = lava()
    print(*ans,sep='\n')


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
blocked={}
found=False
lavablock={}
def lava():
    for _ in range(q):
        r,c = [int(x) for x in input().split()]
        getlava=blocked.get((r,c),False)
        getlavablocks=lavablock.get((r,c),False)
        if getlava:
            del blocked[(r,c)]
            if getlavablocks:
                del lavablock[(r,c)]
        else:
            blocked[(r,c)]=True
        #print(blocked)
        if not lavablock:
            for lav in blocked:
                posx,posy=lav
                if posx==1:
                    newposx=2
                else:
                    newposx=1
                lavprev=blocked.get((newposx,posy),False)
                lavcur=blocked.get((newposx,posy-1),False)
                lavnext=blocked.get((newposx,posy+1),False)
                if lavprev:

                    lavablock[(newposx,c)]=True
                    break
                elif lavcur:

                    lavablock[(newposx,c)]=True
                    break
                elif lavnext:

                    lavablock[(newposx,c)]=True
                    break
        if lavablock:
            yield "No"
        else:
            yield "Yes"

if __name__ == '__main__':
    t,q= [int(x) for x in input().split()]
    ans = lava()
    print(*ans,sep='\n')


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__

blocks={}

lavablocks={}
def newlava():
    for _ in range(q):
        r,c = [int(x) for x in input().split()]
        getlavablocks=blocks.get((r,c),False)
        if r==1:
            newposx=2
        else:
            newposx=1
        lavprev=blocks.get((newposx,c-1),False)
        lavcur=blocks.get((newposx,c),False)
        lavnext=blocks.get((newposx,c+1),False)
        if getlavablocks:
            del blocks[(r,c)]
            freq=lavablocks.get((r,c),0)
            if freq:
                if freq==1:
                    del lavablocks[(r,c)]
                else:
                    lavablocks[(r,c)]=freq-1
            freq=lavablocks.get((newposx,c-1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c-1)]
                else:
                    lavablocks[(newposx,c-1)]=freq-1
            freq=lavablocks.get((newposx,c),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c)]
                else:
                    lavablocks[(newposx,c)]=freq-1
            freq=lavablocks.get((newposx,c+1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c+1)]
                else:
                    lavablocks[(newposx,c+1)]=freq-1

        else:
            blocks[(r,c)]=True

            if lavprev:
                freq=lavablocks.get((newposx,c-1),0)
                lavablocks[(newposx,c-1)]=freq+1
                freq=lavablocks.get((r,c),0)
                lavablocks[(r,c)]=freq+1
            if lavcur:
                freq=lavablocks.get((newposx,c),0)
                lavablocks[(newposx,c)]=freq+1
                freq=lavablocks.get((r,c),0)
                lavablocks[(r,c)]=freq+1
            if lavnext:
                freq=lavablocks.get((newposx,c+1),0)
                lavablocks[(newposx,c+1)]=freq+1
                freq=lavablocks.get((r,c),0)
                lavablocks[(r,c)]=freq+1
        #print(len(lavablocks))
        if len(lavablocks)==1:
            lavablocks.clear()
        if lavablocks:
            yield 'No'
        else:
            yield 'Yes'
        #print(blocks,lavablocks)

if __name__ == '__main__':
    t,q= [int(x) for x in input().split()]
    ans = newlava()
    print(*ans,sep='\n')


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__

blocks={}

lavablocks={}
def newlava():
    for _ in range(q):
        r,c = [int(x) for x in input().split()]
        getlavablocks=blocks.get((r,c),False)
        if r==1:
            newposx=2
        else:
            newposx=1
        lavprev=blocks.get((newposx,c-1),False)
        lavcur=blocks.get((newposx,c),False)
        lavnext=blocks.get((newposx,c+1),False)
        if getlavablocks:
            del blocks[(r,c)]
            freq=lavablocks.get((r,c),0)
            if freq:
                if freq==1:
                    del lavablocks[(r,c)]
                else:
                    lavablocks[(r,c)]=freq-1
            freq=lavablocks.get((newposx,c-1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c-1)]
                else:
                    lavablocks[(newposx,c-1)]=freq-1
            freq=lavablocks.get((newposx,c),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c)]
                else:
                    lavablocks[(newposx,c)]=freq-1
            freq=lavablocks.get((newposx,c+1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c+1)]
                else:
                    lavablocks[(newposx,c+1)]=freq-1

        else:
            blocks[(r,c)]=True

            if lavprev:
                freq=lavablocks.get((newposx,c-1),0)
                lavablocks[(newposx,c-1)]=freq+1
                freq=lavablocks.get((r,c),0)
                lavablocks[(r,c)]=freq+1
            if lavcur:
                freq=lavablocks.get((newposx,c),0)
                lavablocks[(newposx,c)]=freq+1
                freq=lavablocks.get((r,c),0)
                lavablocks[(r,c)]=freq+1
            if lavnext:
                freq=lavablocks.get((newposx,c+1),0)
                lavablocks[(newposx,c+1)]=freq+1
                freq=lavablocks.get((r,c),0)
                lavablocks[(r,c)]=freq+1
        if lavablocks:
            yield 'No'
        else:
            yield 'Yes'
        #print(blocks,lavablocks)

if __name__ == '__main__':
    t,q= [int(x) for x in input().split()]
    ans = newlava()
    print(*ans,sep='\n')


blocked={}

def lava():
    for _ in range(q):
        r,c = [int(x) for x in input().split()]
        getlava=blocked.get((r,c),False)
        if getlava:
            del blocked[(r,c)]
        else:
            blocked[(r,c)]=True
        #print(blocked)
        found=False
        for lav in blocked:
            posx,posy=lav
            if posx==1:
                newposx=2
            else:
                newposx=1
            lavprev=blocked.get((newposx,posy),False)
            lavcur=blocked.get((newposx,posy-1),False)
            lavnext=blocked.get((newposx,posy+1),False)
            if lavprev or lavcur or lavnext:
                found=True
                break
        if found:
            yield "No"
        else:
            yield "Yes"

if __name__ == '__main__':
    t,q= [int(x) for x in input().split()]
    ans = lava()
    print(*ans,sep='\n')


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__

blocks={}

lavablocks={}
def newlava():
    for _ in range(q):
        r,c = [int(x) for x in input().split()]
        getlavablocks=blocks.get((r,c),False)
        if r==1:
            newposx=2
        else:
            newposx=1
        lavprev=blocks.get((newposx,c-1),False)
        lavcur=blocks.get((newposx,c),False)
        lavnext=blocks.get((newposx,c+1),False)
        if getlavablocks:
            del blocks[(r,c)]
            freq=lavablocks.get((r,c),0)
            if freq:
                if freq==1:
                    del lavablocks[(r,c)]
                else:
                    lavablocks[(r,c)]=freq-1
            freq=lavablocks.get((newposx,c-1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c-1)]
                else:
                    lavablocks[(newposx,c-1)]=freq-1
            freq=lavablocks.get((newposx,c),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c)]
                else:
                    lavablocks[(newposx,c)]=freq-1
            freq=lavablocks.get((newposx,c+1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c+1)]
                else:
                    lavablocks[(newposx,c+1)]=freq-1

        else:
            blocks[(r,c)]=True

            if lavprev:
                freq=lavablocks.get((newposx,c-1),0)
                lavablocks[(newposx,c-1)]=freq+1
                freq=lavablocks.get((r,c),0)
                lavablocks[(r,c)]=freq+1
            if lavcur:
                freq=lavablocks.get((newposx,c),0)
                lavablocks[(newposx,c)]=freq+1
                freq=lavablocks.get((r,c),0)
                lavablocks[(r,c)]=freq+1
            if lavnext:
                freq=lavablocks.get((newposx,c+1),0)
                lavablocks[(newposx,c+1)]=freq+1
                freq=lavablocks.get((r,c),0)
                lavablocks[(r,c)]=freq+1
        if len(lavablocks)==1:
            lavablocks={}
        if lavablocks:
            yield 'No'
        else:
            yield 'Yes'
        print(blocks,lavablocks)

if __name__ == '__main__':
    t,q= [int(x) for x in input().split()]
    ans = newlava()
    print(*ans,sep='\n')


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__

blocks={}

lavablocks={}
def newlava():
    for _ in range(q):
        r,c = [int(x) for x in input().split()]
        getlavablocks=blocks.get((r,c),False)
        if r==1:
            newposx=2
        else:
            newposx=1
        lavprev=blocks.get((newposx,c-1),False)
        lavcur=blocks.get((newposx,c),False)
        lavnext=blocks.get((newposx,c+1),False)
        if getlavablocks:
            del blocks[(r,c)]
            freq=lavablocks.get((r,c),0)
            if freq:
                if freq==1:
                    del lavablocks[(r,c)]
                else:
                    lavablocks[(r,c)]=freq-1
            freq=lavablocks.get((newposx,c-1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c-1)]
                else:
                    lavablocks[(newposx,c-1)]=freq-1
            freq=lavablocks.get((newposx,c-1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c)]
                else:
                    lavablocks[(newposx,c)]=freq-1
            freq=lavablocks.get((newposx,c-1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c+1)]
                else:
                    lavablocks[(newposx,c+1)]=freq-1

        else:
            blocks[(r,c)]=True
            if lavprev:
                freq=lavablocks.get((newposx,c-1),0)
                lavablocks[(newposx,c-1)]=freq+1
            elif lavcur:
                freq=lavablocks.get((newposx,c),0)
                lavablocks[(newposx,c)]=freq+1
            elif lavnext:
                freq=lavablocks.get((newposx,c+1),0)
                lavablocks[(newposx,c+1)]=freq+1
        if lavablocks:
            yield 'No'
        else:
            yield 'Yes'
        #print(blocks,lavablocks)

if __name__ == '__main__':
    t,q= [int(x) for x in input().split()]
    ans = newlava()
    print(*ans,sep='\n')


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__

blocks={}

lavablocks={}
def newlava():
    for _ in range(q):
        r,c = [int(x) for x in input().split()]
        getlavablocks=blocks.get((r,c),False)
        if r==1:
            newposx=2
        else:
            newposx=1
        lavprev=blocks.get((newposx,c-1),False)
        lavcur=blocks.get((newposx,c),False)
        lavnext=blocks.get((newposx,c+1),False)
        if getlavablocks:
            del blocks[(r,c)]
            freq=lavablocks.get((r,c),0)
            if freq:
                if freq==1:
                    del lavablocks[(r,c)]
                else:
                    lavablocks[(r,c)]=freq-1
            freq=lavablocks.get((newposx,c-1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c-1)]
                else:
                    lavablocks[(newposx,c-1)]=freq-1
            freq=lavablocks.get((newposx,c-1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c)]
                else:
                    lavablocks[(newposx,c)]=freq-1
            freq=lavablocks.get((newposx,c-1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c+1)]
                else:
                    lavablocks[(newposx,c+1)]=freq-1

        else:
            blocks[(r,c)]=True
            if lavprev:
                freq=lavablocks.get((newposx,c-1),0)
                lavablocks[(newposx,c-1)]=freq+1
            elif lavcur:
                freq=lavablocks.get((newposx,c),0)
                lavablocks[(newposx,c)]=freq+1
            elif lavnext:
                freq=lavablocks.get((newposx,c+1),0)
                lavablocks[(newposx,c+1)]=freq+1
        if lavablocks:
            yield 'No'
        else:
            yield 'Yes'
        print(blocks,lavablocks)

if __name__ == '__main__':
    t,q= [int(x) for x in input().split()]
    ans = newlava()
    print(*ans,sep='\n')


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__

blocks={}

lavablocks={}
def newlava():
    for _ in range(q):
        r,c = [int(x) for x in input().split()]
        getlavablocks=blocks.get((r,c),False)
        if r==1:
            newposx=2
        else:
            newposx=1
        lavprev=blocks.get((newposx,c-1),False)
        lavcur=blocks.get((newposx,c),False)
        lavnext=blocks.get((newposx,c+1),False)
        if getlavablocks:
            del blocks[(r,c)]
            freq=lavablocks.get((newposx,c-1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c-1)]
                else:
                    lavablocks[(newposx,c-1)]=freq-1
                freq=lavablocks.get((r,c),0)
                if freq:
                    if freq==1:
                        del lavablocks[(r,c)]
                    else:
                        lavablocks[(r,c)]=freq-1

            freq=lavablocks.get((newposx,c),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c)]
                else:
                    lavablocks[(newposx,c)]=freq-1
                freq=lavablocks.get((r,c),0)
                if freq:
                    if freq==1:
                        del lavablocks[(r,c)]
                    else:
                        lavablocks[(r,c)]=freq-1
            freq=lavablocks.get((newposx,c+1),0)
            if freq:
                if freq==1:
                    del lavablocks[(newposx,c+1)]
                else:
                    lavablocks[(newposx,c+1)]=freq-1
                freq=lavablocks.get((r,c),0)
                if freq:
                    if freq==1:
                        del lavablocks[(r,c)]
                    else:
                        lavablocks[(r,c)]=freq-1
        else:
            blocks[(r,c)]=True

            if lavprev:
                freq=lavablocks.get((newposx,c-1),0)
                lavablocks[(newposx,c-1)]=freq+1
                freq=lavablocks.get((r,c),0)
                lavablocks[(r,c)]=freq+1
            if lavcur:
                freq=lavablocks.get((newposx,c),0)
                lavablocks[(newposx,c)]=freq+1
                freq=lavablocks.get((r,c),0)
                lavablocks[(r,c)]=freq+1
            if lavnext:
                freq=lavablocks.get((newposx,c+1),0)
                lavablocks[(newposx,c+1)]=freq+1
                freq=lavablocks.get((r,c),0)
                lavablocks[(r,c)]=freq+1
        #print(len(lavablocks))

        if lavablocks:
            yield 'No'
        else:
            yield 'Yes'
        #print(blocks,lavablocks)

if __name__ == '__main__':
    t,q= [int(x) for x in input().split()]
    ans = newlava()
    print(*ans,sep='\n')


import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log2, ceil
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
from bisect import insort
from collections import Counter
from collections import deque
from heapq import heappush,heappop,heapify
from itertools import permutations,combinations
mod = int(1e9)+7

ip = lambda : int(stdin.readline())
inp = lambda: map(int,stdin.readline().split())
ips = lambda: stdin.readline().rstrip()
out = lambda x : stdout.write(str(x)+"\n")

t = 1
for _ in range(t):
    n,q = inp()
    arr = [[False]*n for i in range(2)]
    ct = 0
    for i in range(q):
        a,b = inp()
        a,b = a-1,b-1
        if arr[a][b] == True:
            arr[a][b] = False
            if a == 0:
                ch = False
                if b-1>= 0:
                    ch = ch or arr[a+1][b-1]
                if b+1<n:
                    ch = ch or arr[a+1][b+1]
                ch = ch or arr[a+1][b]
                if ch:
                    ct -= 1
            else:
                ch = False
                if b-1>= 0:
                    ch = ch or arr[a-1][b-1]
                if b+1<n:
                    ch = ch or arr[a-1][b+1]
                ch = ch or arr[a-1][b]
                if ch:
                    ct -= 1
        else:
            arr[a][b] = True
            if a == 0:
                ch = False
                if b-1>= 0:
                    ch = ch or arr[a+1][b-1]
                if b+1<n:
                    ch = ch or arr[a+1][b+1]
                ch = ch or arr[a+1][b]
                if ch:
                    ct += 1
            else:
                ch = False
                if b-1>= 0:
                    ch = ch or arr[a-1][b-1]
                if b+1<n:
                    ch = ch or arr[a-1][b+1]
                ch = ch or arr[a-1][b]
                if ch:
                    ct += 1
        if ct == 0:
            out("Yes")
        else:
            out("No")


import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log2, ceil
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
from bisect import insort
from collections import Counter
from collections import deque
from heapq import heappush,heappop,heapify
from itertools import permutations,combinations
mod = int(1e9)+7

ip = lambda : int(stdin.readline())
inp = lambda: map(int,stdin.readline().split())
ips = lambda: stdin.readline().rstrip()
out = lambda x : stdout.write(str(x)+"\n")

t = 1
for _ in range(t):
    n,q = inp()
    arr = [[False]*n for i in range(2)]
    ct = 0
    for i in range(q):
        a,b = inp()
        a,b = a-1,b-1
        if arr[a][b] == True:
            arr[a][b] = False
            if a == 0:
                ch = False
                if b-1>= 0:
                    ch = ch or arr[a+1][b-1]
                if b+1<n:
                    ch = ch or arr[a+1][b+1]
                ch = ch or arr[a+1][b]
                if ch:
                    ct -= 1
            else:
                ch = False
                if b-1>= 0:
                    ch = ch or arr[a-1][b-1]
                if b+1<n:
                    ch = ch or arr[a-1][b+1]
                ch = ch or arr[a+1][b]
                if ch:
                    ct -= 1
        else:
            arr[a][b] = True
            if a == 0:
                ch = False
                if b-1>= 0:
                    ch = ch or arr[a+1][b-1]
                if b+1<n:
                    ch = ch or arr[a+1][b+1]
                ch = ch or arr[a+1][b]
                if ch:
                    ct += 1
            else:
                ch = False
                if b-1>= 0:
                    ch = ch or arr[a-1][b-1]
                if b+1<n:
                    ch = ch or arr[a-1][b+1]
                ch = ch or arr[a-1][b]
                if ch:
                    ct += 1
        if ct == 0:
            out("Yes")
        else:
            out("No")


import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log2, ceil
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
from bisect import insort
from collections import Counter
from collections import deque
from heapq import heappush,heappop,heapify
from itertools import permutations,combinations
mod = int(1e9)+7

ip = lambda : int(stdin.readline())
inp = lambda: map(int,stdin.readline().split())
ips = lambda: stdin.readline().rstrip()
out = lambda x : stdout.write(str(x)+"\n")

t = 1
for _ in range(t):
    n,q = inp()
    arr = [[False]*n for i in range(2)]
    ct = 0
    for i in range(q):
        a,b = inp()
        a,b = a-1,b-1
        if arr[a][b] == True:
            arr[a][b] = False
            if a == 0:
                ch = False
                if b-1>= 0:
                    if arr[a+1][b-1]:
                        ct -= 1
                if b+1<n:
                    if arr[a+1][b+1]:
                        ct -= 1
                if arr[a+1][b]:
                    ct -= 1

            else:
                ch = False
                if b-1>= 0:
                    if arr[a-1][b-1]:
                        ct -= 1
                if b+1<n:
                    if arr[a-1][b+1]:
                        ct -= 1
                if arr[a-1][b]:
                    ct -= 1
        else:
            arr[a][b] = True
            if a == 0:
                ch = False
                if b-1>= 0:
                    if arr[a+1][b-1]:
                        ct += 1
                if b+1<n:
                    if arr[a+1][b+1]:
                        ct += 1
                if arr[a+1][b]:
                    ct += 1
            else:
                ch = False
                if b-1>= 0:
                    if arr[a-1][b-1]:
                        ct += 1
                if b+1<n:
                    if arr[a-1][b+1]:
                        ct += 1
                if arr[a-1][b]:
                    ct += 1
        if ct == 0:
            out("Yes")
        else:
            out("No")


n, q = map(int, input().split())
l = [[False for i in range(n)] for _ in range(2)]
ans = True
banned = 0

for _ in range(q):
    r, c = map(int, input().split())
    r -= 1
    c -= 1
    tr = 1 if not(l[r][c]) else -1
    l[r][c] = not(l[r][c])

    for i in range(-1, 2):
        if c+i >= 0 and c+i < n and l[1-r][c+i]:
            banned += tr

    if not(banned):
        print("Yes")
    else:
        print("No")


n, q = map(int, input().split())
ans_1 = True
ans_2 = True
banned_1 = set()
banned_2 = set()

for _ in range(q):
    r, c = map(int, input().split())
    if r == 1:
        ans_1 = False
        if c in banned_1:
            banned_1.remove(c)
        else:
            banned_1.add(c)
        if not(len(banned_1)):
            ans_1 = True
    else:
        ans_2 = False
        if c in banned_2:
            banned_2.remove(c)
        else:
            banned_2.add(c)
        if not(len(banned_2)):
            ans_2 = True

    if ans_1 or ans_2:
        print("Yes")
    else:
        print("No")


def arr_inp(n):
    if n == 1:
        return [int(x) for x in stdin.readline().split()]
    elif n == 2:
        return [float(x) for x in stdin.readline().split()]
    else:
        return [str(x) for x in stdin.readline().split()]

from sys import stdin
from collections import defaultdict

n, q = arr_inp(1)
col, arr = defaultdict(int), defaultdict(int)

cols, rows, rows2 = 0, 0, 0
for i in range(q):
    x, y = arr_inp(1)
    if arr[x, y]:
        arr[x, y] = 0
        if col[y] == 2:
            rows -= 1
            if not rows:
                cols = 0
        col[y] -= 1
        z = 1
        if x == 1:
            z = 2
        if arr[z, y + 1]:
            rows2 -= 1
        if arr[z, y - 1]:
            rows2 -= 1

    else:
        arr[x, y] = 1
        col[y] += 1
        if col[y] == 2:
            rows += 1
            cols = 2
        z = 1
        if x == 1:
            z = 2
        if arr[z, y + 1]:
            rows2 += 1
        if arr[z, y - 1]:
            rows2 += 1

    if cols == 2 or rows2:
        print('NO')
    else:
        print('YES')


N, Q = map(int, input().split())

walls, lavas = 0, set()

for q in range(Q):
	r, c = map(lambda s: int(s) - 1, input().split())

	nr = (r + 1) % 2
	for dc in range(-1, 2):
		nc = c + dc

		if (nr, nc) in lavas:
			# If there wasn't lava in (r, c) before, then now a wall is created
			# If there was    lava in (r, c), then now a wall is removed
			walls += (1 if (r, c) not in lavas else -1)

	# Add/remove at the end of the for loop to not trip up the ternary operator
	lavas.add((r, c)) if (r, c) not in lavas else lavas.remove((r, c))

	print("Yes" if walls == 0 else "No")


n, q = map(int, input().split())
m = [[0] * n for i in range(2)]
cnt = 0
for i in range(q):
    a, b = map(int, input().split())
    if m[a - 1][b - 1]:
        m[a - 1][b - 1] = 0
        if sum(m[2 - a][b - 2:b + 1]):
            cnt -= 1
    else:
        m[a - 1][b - 1] = 1
        if sum(m[2 - a][b - 2:b + 1]):
            cnt += 1
    if cnt:
        print('No')
    else:
        print('Yes')


n, q = map(int, input().split())
a = [[0 for i in range(n)] for j in range(2)]
cnt = 0
for i in range(q):
    x, y = map(int, input().split())
    if a[x - 1][y - 1]:
        k = -1
    else:
        k = 1
    i = 1 - x + 1
    for j in range(max(0, y - 2), min(n, y + 1)):
        if a[i][j] == 1:
            cnt += k
    a[x - 1][y - 1] = 1 - a[x - 1][y - 1]
    if cnt or a[0][0] or a[1][n - 1]:
        print('No')
    else:
        print('Yes')


n, q = map(int, input().split())
m = [[0] * n for i in range(2)]
cnt = 0
for i in range(q):
    a, b = map(int, input().split())
    if m[a - 1][b - 1]:
        m[a - 1][b - 1] = 0
        if sum(m[2 - a][b - 2:b + 1]):
            cnt -= 1
    else:
        m[a - 1][b - 1] = 1
        if sum(m[2 - a][b - 2:b + 1]):
            cnt += 1
    if cnt or m[0][0] or m[1][n - 1]:
        print('No')
    else:
        print('Yes')


n, q = map(int, input().split())
m = [[0] * n for i in range(2)]
cnt = 0
for i in range(q):
    a, b = map(int, input().split())
    if m[a - 1][b - 1]:
        m[a - 1][b - 1] = 0
        cnt -= sum(m[2 - a][b - 2:b + 1])
    else:
        m[a - 1][b - 1] = 1
        cnt += sum(m[2 - a][b - 2:b + 1])
    if cnt or m[0][0] or m[1][n - 1]:
        print('No')
    else:
        print('Yes')