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

static const int MOD = 1000000007;

struct DSU {
    int n;
    vector<int> p, r;
    DSU(int _n): n(_n), p(n, -1), r(n, 0) {}
    int find(int x) {
        return p[x] < 0 ? x : p[x] = find(p[x]);
    }
    bool unite(int a, int b) {
        a = find(a); b = find(b);
        if (a == b) return false;
        if (r[a] < r[b]) swap(a, b);
        p[a] += p[b];
        p[b] = a;
        if (r[a] == r[b]) r[a]++;
        return true;
    }
    int size(int x) {
        return -p[find(x)];
    }
};

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N;
    cin >> N;
    vector<tuple<int,int,int>> edges(N-1);
    for(int i = 0; i < N-1; i++){
        int a,b,c;
        cin >> a >> b >> c;
        --a; --b;
        edges[i] = make_tuple(a,b,c);
    }

    long long answer = 0;
    // Precompute (1<<k) % MOD
    vector<long long> bitval(31);
    bitval[0] = 1;
    for(int k = 1; k <= 30; k++){
        bitval[k] = (bitval[k-1] * 2) % MOD;
    }

    // For each bit position k = 0..30
    for(int k = 0; k <= 30; k++){
        DSU dsu(N);
        // unite all edges whose k-th bit is 1
        for(auto &e : edges){
            int u,v,c;
            tie(u,v,c) = e;
            if ((c >> k) & 1){
                dsu.unite(u, v);
            }
        }
        // count component sizes
        vector<int> comp_size(N, 0);
        for(int v = 0; v < N; v++){
            int r = dsu.find(v);
            comp_size[r]++;
        }
        // for each component of size s, number of pairs is s*(s-1)/2
        long long pair_count = 0;
        for(int r = 0; r < N; r++){
            int s = comp_size[r];
            if (s >= 2){
                pair_count = (pair_count + 1LL * s * (s-1) / 2) % MOD;
            }
        }
        // contribute bitval[k] * pair_count
        answer = (answer + bitval[k] * pair_count) % MOD;
    }

    cout << answer << "\n";
    return 0;
}