Record

#include <bits/stdc++.h>

namespace solve
{
	const int N=1e5+5;
	
	struct mergeset
	{
		const static int N=solve::N<<1;
		struct op{int u,v,dh;};
		std::stack<op> oper;
		int f[N],r[N];
		void init()
		{
			for(int i=0;i<N;i++)
				f[i]=i;
		}
		int find(int x)
		{
			if(f[x]==x)
				return x;
			else
				return find(f[x]);
		}
		void merge(int x,int y)
		{
			x=find(x);y=find(y);
			if(x==y)
			{
				oper.push({0,0,0});
				return;
			}
			if(r[x]>r[y])
				std::swap(x,y);
			f[x]=y;
			r[y]+=(r[x]==r[y]);
			oper.push({x,y,r[x]==r[y]});
		}
		void undo(int step)
		{
			while(step--)
			{
				op p=oper.top();
				oper.pop();
				r[p.v]-=p.dh;
				f[p.u]=p.u;
			}
		}
	}ms;
	
	int n,m,k;
	struct edge{int u,v,s,e;}E[N<<1];
	struct segtree
	{
		struct seg
		{
			int l,r;
			std::vector<edge> e;
		}s[N<<2];
		int ls(int p){return p<<1;}
		int rs(int p){return p<<1|1;}
		void build(int l,int r,int p=1)
		{
			s[p]={l,r,{}};
			if(l==r) return;
			int mid=l+r>>1;
			build(l,mid,ls(p));
			build(mid+1,r,rs(p));
		}
		void insert(edge e,int p=1)
		{
			if(e.s<=s[p].l&&s[p].r<=e.e)
			{
				s[p].e.push_back(e);
				return;
			}
			int mid=s[p].l+s[p].r>>1;
			if(e.s<=mid) insert(e,ls(p));
			if(mid<e.e) insert(e,rs(p));
		}
		void dfs(int p=1)
		{
			bool legal=true;
			int did=0;
			for(auto e:s[p].e)
			{
				int u=e.u,v=e.v;
				if(ms.find(u)==ms.find(v))
				{
					legal=false;
					break;
				}
				ms.merge(u,v+n);
				ms.merge(v,u+n);
				did++;
			}
			if(legal)
			{
				if(s[p].l==s[p].r)
					std::cout<<"Yes\n";
				else
				{
					dfs(ls(p));
					dfs(rs(p));
				}
			}
			else
			{
				for(int i=s[p].l;i<=s[p].r;i++)
					std::cout<<"No\n";
			}
			ms.undo(did);
		}
	}s;
	
	void main()
	{
		std::cin>>n>>m>>k;
		s.build(1,k);
		ms.init();
		for(int i=1;i<=m;i++)
		{
			int u,v,l,r;
			std::cin>>u>>v>>l>>r;
			E[i]={u,v,l+1,r};
			if(l!=r)
				s.insert(E[i]);
		}
		s.dfs();
	}
}

int main()
{
	solve::main();
	return 0;
}