#include "happy.h"
using namespace std;
vector<int> comp[2001];
long long drum[2001][2001],actdrum[2001][2001];
vector<long long> muchii[2001];
vector<long long> acdrum[2001];
vector<long long> ans;
bool activ[2001];
std::vector <long long int> happy (int N, int Q, std::vector <int> u, std::vector <int> v, std::vector <int> h, std::vector <int> t, std::vector <int> l, std::vector <int> r)
{
    for(int i=0; i<N-1; i++)
    {
        drum[u[i]][v[i]]=h[i];
        drum[v[i]][u[i]]=h[i];
        muchii[u[i]].push_back(v[i]);
        muchii[v[i]].push_back(u[i]);
    }
    for(int i=0; i<N; i++)
    {
        for(int j=0; j<N; j++)
        {
            actdrum[i][j]=-1;
        }
    }
    long long sum=0;
    for(int i=0; i<Q; i++)
    {
        int type=t[i];
        int x=l[i];
        int y=r[i];
        if(type==1)
        {
            for(int j=x; j<=y; j++)
            {
                if(activ[j])
                {
                    continue;
                }
                activ[j]=1;
                vector<long long> cucn;
                for(int k=0; k<muchii[j].size(); k++)
                {
                    if(!activ[muchii[j][k]])
                    {
                        continue;
                    }
                    cucn=acdrum[j];
                    int nxt=muchii[j][k];
                    if(actdrum[j][nxt]==-1)
                    {
                        sum+=drum[j][nxt];
                    }
                    acdrum[j].push_back(nxt);
                    acdrum[nxt].push_back(j);
                    actdrum[j][nxt]=drum[j][nxt];
                    actdrum[nxt][j]=drum[nxt][j];
                    for(int w=0; w<cucn.size(); w++)
                    {
                        if(cucn[w]==-1)
                        {
                            continue;
                        }
                        if(actdrum[nxt][cucn[w]]==-1)
                        {
                            actdrum[nxt][cucn[w]]=actdrum[j][nxt]^actdrum[j][cucn[w]];
                            actdrum[cucn[w]][nxt]=actdrum[nxt][cucn[w]];
                            sum+=actdrum[nxt][cucn[w]];
                        }
                    }
                    for(int h=0; h<acdrum[nxt].size(); h++)
                    {
                        int val=acdrum[nxt][h];
                        if(val==-1)
                        {
                            continue;
                        }
                        if(val==j)
                        {
                            continue;
                        }
                        acdrum[j].push_back(val);
                        acdrum[val].push_back(j);
                        if(actdrum[j][val]==-1)
                        {
                            actdrum[j][val]=actdrum[j][nxt]^actdrum[nxt][val];
                            actdrum[val][j]=actdrum[j][val];
                            sum+=actdrum[j][val];
                        }
                        for(int w=0; w<cucn.size(); w++)
                        {
                            if(cucn[w]==-1)
                            {
                                continue;
                            }
                            if(actdrum[val][cucn[w]]==-1)
                            {
                                actdrum[cucn[w]][val]=actdrum[j][val]^actdrum[cucn[w]][j];
                                actdrum[val][cucn[w]]=actdrum[cucn[w]][val];
                                sum+=actdrum[val][cucn[w]];
                            }
                        }
                    }
                }
            }
        }
        else
        {
            for(int j=x; j<=y; j++)
            {
                if(!activ[j])
                {
                    continue;
                }
                activ[j]=0;
                for(int w=0; w<acdrum[j].size(); w++)
                {
                    int val=acdrum[j][w];
                    if(val==-1)
                    {
                        continue;
                    }
                    sum-=actdrum[j][val];
                    actdrum[j][val]=-1;
                    for(int k=0; k<acdrum[val].size(); k++)
                    {
                        if(acdrum[val][k]==j)
                        {
                            acdrum[val].erase(acdrum[val].begin()+k);
                            break;
                        }
                    }
                    actdrum[val][j]=-1;
                }
                acdrum[j].clear();
            }
        }
        ans.push_back(sum);
    }
    return ans;
}

