#include<bits/stdc++.h>

#define ll long long

#define int long long

#define fir first

#define sec second

#define pii pair<int,int>

#define isz(v) (int)(v.size())

using namespace std;



const int maxn=500005;

const int inf=0x3f3f3f3f3f3f3f3f;



namespace Solve {

	struct Val {

		int x,y,ans;

		Val operator + (const Val &rhs) const {

			return {min(x,rhs.x),min(y,rhs.y),ans+rhs.ans};

		}

	};

	struct Tag {

		int x,y,t,d;

		Tag operator + (const Tag &rhs) const {

			return {x+rhs.x,y+rhs.y,t+rhs.t,d+rhs.d-t*rhs.x};

		}

	};

	struct ST {

		struct Node {

			int l,r;

		} a[maxn*4];

		Val val[maxn*4];

		Tag tag[maxn*4];

		void pushup(int x) {

			val[x]=val[x*2]+val[x*2+1];

		}

		void spread(int x,Tag t) {

			val[x].x+=t.x;

			val[x].y+=t.y;

			val[x].ans+=val[x].x*t.t+t.d;

			tag[x]=tag[x]+t;

		}

		void pushdown(int x) {

			int p=val[x*2].y,q=val[x*2+1].y;

			if(p<=q) {

				spread(x*2,tag[x]);

			} else {

				Tag t=tag[x];

				t.t=t.d=0;

				spread(x*2,t);

			}

			if(p>=q) {

				spread(x*2+1,tag[x]);

			} else {

				Tag t=tag[x];

				t.t=t.d=0;

				spread(x*2+1,t);

			}

			tag[x]={};

		}

		void build(int l,int r,int k=1) {

			a[k]={l,r};

			tag[k]={};

			if(l==r) {

				val[k]={0,1,0};

				return ;

			}

			int mid=(l+r)>>1;

			build(l,mid,k*2);

			build(mid+1,r,k*2+1);

			pushup(k);

		}

		void update(int l,int r,Tag t,int k=1) {

			if(a[k].r<l||a[k].l>r) {

				return ;

			}

			if(l<=a[k].l&&a[k].r<=r) {

				spread(k,t);

				return ;

			}

			pushdown(k);

			update(l,r,t,k*2);

			update(l,r,t,k*2+1);

			pushup(k);

		}

		void dfs(int k=1) {

			if(a[k].l==a[k].r) {

				cout<<val[k].ans<<"\n";

				return ;

			}

			pushdown(k);

			dfs(k*2);

			dfs(k*2+1);

		}

		void print(int k=1) {

			cerr<<val[k].x<<" "<<val[k].y<<" "<<val[k].ans<<"\n";

			if(a[k].l==a[k].r) {

				return ;

			}

			pushdown(k);

			print(k*2);

			print(k*2+1);

		}

	} seg;

	int a[maxn];

	int p[maxn];

	vector<pii> v1[maxn];

	vector<pii> v2[maxn];

	void clear() {

		

	}

	void add(int x,int y,int l,int r) {

		if(p[x]>p[y]) {

			swap(x,y);

		}

		// cerr<<x<<" "<<y<<": "<<l<<" "<<r<<"\n";

		v1[p[x]].push_back({l,r});

		v2[p[y]].push_back({l,r});

	}

	void main(int tid) {

		int n,m;

		cin>>n>>m;

		map<pii,int> t;

		for(int i=1;i<=n-1;i++) {

			int x,y;

			cin>>x>>y;

			if(x>y) {

				swap(x,y);

			}

			t[{x,y}]=0;

		}

		for(int i=1;i<=n-1;i++) {

			cin>>a[i];

			p[a[i]]=i;

		}

		p[1]=n;

		for(int i=1;i<=m;i++) {

			int x,y;

			cin>>x>>y;

			if(x>y) {

				swap(x,y);

			}

			add(x,y,t[{x,y}],i-1);

			t[{x,y}]=-1;

			cin>>x>>y;

			if(x>y) {

				swap(x,y);

			}

			t[{x,y}]=i;

		}

		for(auto p:t) {

			if(p.sec==-1) {

				continue;

			}

			pii r=p.fir;

			add(r.fir,r.sec,p.sec,m);

		}if(m>8000)return ;

		seg.build(0,m);

		for(int i=1;i<=n-1;i++) {

			seg.update(0,m,{1,-1});

			for(pii p:v1[i]) {

				// cerr<<"?\n";

				seg.update(p.fir,p.sec,{0,1});

			}

			for(pii p:v2[i]) {

				seg.update(p.fir,p.sec,{-1,0});

			}

			if(seg.val[1].y==1) {

				seg.update(0,m,{0,0,1});

			}

			// seg.print();

			// cerr<<"-----\n";



			// cerr<<seg.val[1].x<<" "<<seg.val[1].y<<" "<<seg.val[1].ans<<"\n";

		}

		seg.dfs();

	}

	void init() {

		

	}

}



signed main() {

#ifndef ONLINE_JUDGE

	freopen("data.in","r",stdin);

	freopen("mine.out","w",stdout);

#endif

	ios::sync_with_stdio(false);

	cin.tie(0),cout.tie(0);

	int T=1;

//	cin>>T;

	Solve::init();

	for(int t=1;t<=T;t++) {

		Solve::main(t);

		Solve::clear();

	}

#ifndef ONLINE_JUDGE

	cerr<<"Time: "<<(1.0*clock()/CLOCKS_PER_SEC)*1000<<"ms\n";

#endif

}