树剖WA 0pts 求调

#include<bits/stdc++.h>
#define int long long
const int MAXM=0x66ccf;
using namespace std;
inline int read(){
    int s=0,w=1;char ch=getchar();
    while(ch<'0'||ch>'9'){ if(ch=='-') w=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){ s=s*10+ch-'0';ch=getchar();}
    return s*w;
}
inline void write(int x) {
    if(x<0){x=-x;putchar('-');}
    if(x<=9){putchar(x+'0');return;}
    write(x/10);putchar(x%10+'0');
}
const int N=0x66CCF,INF=0X66CCFF0712;
int head[MAXM],NEXT[MAXM],TO[MAXM],cnt,tot,a[MAXM];
struct node{
    int fa,dep,siz,son,top;
    int dfn,rnk;
}T[MAXM];
struct St{
    int l,r,siz;
    int lazy,dat;
}t[MAXM];
namespace Grape{
    inline void add(int u,int v){
        NEXT[++tot]=head[u];
        TO[tot]=v;
        head[u]=tot;
    }
}
#define add Grape::add
namespace ST{
    #define mid (l+r)/2
    #define lC q<<1
    #define rC q<<1|1
    void build(int q,int l,int r){
        t[q].l=l;
        t[q].r=r;
        t[q].siz=r-l+1;
        if(l==r){
            t[q].dat=a[T[l].rnk];
            return;
        }
        build(lC,l,mid);
        build(rC,mid+1,r);
        t[q].dat=t[lC].dat+t[rC].dat;
    }
    void lazy(int q){
        t[lC].lazy+=t[q].lazy;
        t[lC].dat+=(t[lC].siz)*t[q].lazy;
        t[rC].lazy+=t[q].lazy;
        t[rC].dat+=(t[rC].siz)*t[q].lazy;
        t[q].lazy=0;
    }
    void change(int q,int l,int r,int v){
        if(t[q].l>r||t[q].r<l) return;
        if(t[q].l>=l && t[q].r<=r){
            t[q].lazy+=v;
            t[q].dat+=t[q].siz*v;
            return;
        }
        if(t[q].lazy!=0)
            lazy(q);
        change(lC,l,r,v);
        change(rC,l,r,v);
        t[q].dat=t[lC].dat+t[rC].dat;
    }
    int asksum(int q,int l,int r){
        if(t[q].l>r || t[q].r<l) 
            return 0;
        if(t[q].l>=l && t[q].r<=r) 
            return t[q].dat;
        if(t[q].lazy!=0) 
            lazy(q);
        return asksum(lC,l,r)+asksum(rC,l,r); 
    }
}
namespace killTree{
    inline void clear(){
        memset(T,0,sizeof(T));
        memset(head,0,sizeof(head));
        memset(NEXT,0,sizeof(NEXT));
        memset(TO,0,sizeof(TO));
        memset(t,0,sizeof(t));
        for(int i=0;i<=0x66ccf;i++)
            a[i]=1;
        tot=cnt=0;
    }
    inline void Dfs1(int q){
        T[q].son=-1;
        T[q].siz=1;
        for(int j=head[q];j;j=NEXT[j]){
            if(T[TO[j]].dep) continue;
            T[TO[j]].dep=T[q].dep+1;
            T[TO[j]].fa=q;
            Dfs1(TO[j]);
            T[q].siz+=T[TO[j]].siz;
            if((T[q].son==-1) || (T[TO[j]].siz>T[T[q].son].siz)) T[q].son=TO[j];
        }
    }
    inline void Dfs2(int q,int v){
        T[q].top=v;
        T[q].dfn=++cnt;
        T[cnt].rnk=q;
        if(T[q].son==-1)
            return;
        Dfs2(T[q].son,v);
        for(int j=head[q];j;j=NEXT[j]){
            if((TO[j]!=T[q].fa)&&(TO[j]!=T[q].son))
                Dfs2(TO[j],TO[j]);
        }
    }
    inline void TreeAdd(int x,int y,int val){
        while(T[x].top!=T[y].top){
            if(T[T[x].top].dep<T[T[y].top].dep) 
                std::swap(x,y);
            ST::change(1,T[T[x].top].dfn,T[x].dfn,val);
            x=T[T[x].top].fa;
        }
        if(T[x].dep>T[y].dep) 
            std::swap(x,y);
        ST::change(1,T[x].dfn,T[y].dfn,val);
    }
    inline int TreeSum(int x,int y){
        int ans=0;
        while(T[x].top!=T[y].top){
            if(T[T[x].top].dep<T[T[y].top].dep) std::swap(x,y);
            ans=ans+ST::asksum(1,T[T[x].top].dfn,T[x].dfn);
            x=T[T[x].top].fa;
        }
        if(T[x].dep>T[y].dep) std::swap(x,y);
        return ans+ST::asksum(1,T[x].dfn,T[y].dfn);
    }
    inline void AddTree(int x,int val){
        ST::change(1,T[x].dfn,T[x].dfn+T[x].siz-1,val);
    }
    inline int AskTree(int x){
        return ST::asksum(1,T[x].dfn,T[x].dfn+T[x].siz-1);
    }
}
signed main(){
    // freopen("1.in","r",stdin);
    int d=read(),t=read();
    while(t--){
        int n=read(),q=read();
        killTree::clear();
        for(int i=1;i<n;i++){
            int x=read(),y=read();
            add(x,y);add(y,x);
        }
        T[1].dep=1;
        killTree::Dfs1(1);
        killTree::Dfs2(1,1);
        ST::build(1,1,n);
        for(int i=1;i<=q;i++){
            int a=read(),b=read(),da=read(),db=read();
            if(da>=killTree::TreeSum(a,b))
                cout<<"Zayin"<<endl;
            else if(da>db) cout<<"Zayin"<<endl;
            else if(da<db) cout<<"Ziyin"<<endl;
            else cout<<"Draw"<<endl;
        }
    }
}