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

using lli = long long int;
using ii = pair<int, lli>;

const int MAXN = 2e5;
const lli MOD = 1e9+7;

int n;
vector<ii> adj[MAXN+1];

lli rootXor[MAXN+1];
void dfs(int u, int p, lli x) {
    rootXor[u] = x;

    for(ii v: adj[u]) {
        if(v.first == p) {
            continue;
        }

        dfs(v.first, u, x ^ v.second);
    }
}

lli safeMult(lli a, lli b) {
    if(!b) {
        return 0;
    }

    if(b%2) {
        return (safeMult(a, b-1) + a) % MOD;
    }
    else {
        lli aux = safeMult(a, b/2);
        return (aux + aux) % MOD;
    }
}

int main() {
    scanf("%d", &n);

    for(int i=0; i<n-1; i++) {
        int u, v;
        lli w;
        scanf("%d %d %lld", &u, &v, &w);

        adj[u].push_back({v, w});
        adj[v].push_back({u, w});
    }

    dfs(1, 1, 0);

    vector<lli> ones(60, 0);

    lli ans = 0;
    for(int i=1; i<=n; i++) {
        lli cand = 0;
        for(int j=0; j<60; j++) {
            lli zeroes = (i-1)-ones[j];
            if(rootXor[i]&(lli(1) << j)) {
                cand += safeMult(lli(1) << j, zeroes);
            }
            else {
                cand += safeMult(lli(1) << j, ones[j]);
            }
            cand = cand % MOD;
        }
        ans = (ans + cand) % MOD;

        for(int j=0; j<60; j++) {
            if(rootXor[i]&(lli(1) << j)) {
                ones[j]++;
            }
        }
    }
    printf("%lld\n", ans);
}

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
#define sc(x) scanf("%lld",&(x));
int n;
vector<pair<int,int> > G[200005];
int dp[200005][62][2];
const int mod = 1e9+7;
int ans = 0;
void dfs(int x,int fa)
{
    int w,t;
    for(auto &a : G[x])
    {
        if(a.first != fa)
        {
            dfs(a.first,x);
            w = a.second;

            for(int i = 0; i <= 60; i++)
            {
                if((w >> i)&1)
                {
                    dp[x][i][0] += dp[a.first][i][1];
                    dp[x][i][1] += dp[a.first][i][0] + 1;
                }
                else
                {
                    dp[x][i][0] += dp[a.first][i][0] + 1;
                    dp[x][i][1] += dp[a.first][i][1] ;
                }
            }

        }
    }
    for(auto &a:G[x]){
        if(a.first != fa)
        {
           t = 1;
            w = a.second;

            for(int i = 0; i <= 60; i++)
            {
                if((w >> i)&1)
                {
                    ans += ((dp[x][i][0] - dp[a.first][i][1])*(dp[a.first][i][0] + 1)%mod)*t%mod;
                    ans %= mod;
                    ans += ((dp[x][i][1] - dp[a.first][i][0] -1)*(dp[a.first][i][1])%mod) *t %mod;
                    ans %= mod;
                }
                else
                {
                    ans += (((dp[x][i][0] - dp[a.first][i][0]-1)*dp[a.first][i][1])%mod*t)%mod;
                    ans %= mod;
                    ans += (((dp[x][i][1] - dp[a.first][i][1] )*(dp[a.first][i][0]+1))%mod*t)%mod;
                    ans %= mod;
                }
                t *= 2;
                t %= mod;
            }
            /*for(int i = 0; i <= 60; i++){
                if(w>>i){
                    ans += (dp[x][i][0] - (dp[a.first][i][1] + 1)) *(dp[x][i][1] - (dp[a.first][i][0] + 1));
                }
            }*/

        }
    }
    w = 1;
     for(int j = 0; j <= 60; j++){
            ans += 2*dp[x][j][1] * w;
            w *= 2;
            w %= mod;
            ans %= mod;
    }

}
int inv(int x){
    int n = mod-2;
    int ans = 1;
    while(n){
        if(n&1){
            ans = ans*x;
            ans %= mod;
        }
        x = (x*x) %mod;
        n>>=1;
    }
    return ans;
}
signed main()
{
   
    sc(n)
    int a,b,w;
    for(int i = 0; i < n-1; i++)
    {
        sc(a)sc(b)sc(w)
        G[a].push_back({b,w});
        G[b].push_back({a,w});
    }
    dfs(1,-1);
    w = 1;


    cout << (ans*inv(2))%mod << '\n';

}
