class DisjointSet:
    def __init__(self, nodes):
        self.parent = {x : x for x in nodes}
        self.rank = {x : 0 for x in nodes}

    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]

    def add_node(self, x):
        if x not in self.parent:
            self.parent[x] = x
            self.rank[x] = 0

    def union(self, x, y):
        self.add_node(x)
        self.add_node(y)

        x_root = self.find(x)
        y_root = self.find(y)

        if x_root == y_root:
            return
        if self.rank[x_root] < self.rank[y_root]:
            x_root, y_root = y_root, x_root
        self.parent[y_root] = x_root
        self.rank[x_root] += self.rank[y_root]

def solve(edges):
    nodes = set()    
    for u, v, color in edges:
        nodes.add(u)
        nodes.add(v)

    ds = DisjointSet(nodes)
    for u, v, color in edges:
				# Two nodes can be connected through a black edge. Any other node connected through a black edge to these previous nodes will then belong to the same set of nodes all connected through black edges. A node that belongs to a black edge subset cannot be connected with another node belonging to the same or another black edge subset.
        if color == 'b':
            ds.union(u, v)
    
    subsets_sizes = {}
    for node in nodes:
        root = ds.find(node)
        subsets_sizes[root] = subsets_sizes.get(root, 0) + 1
    
    n = len(nodes)
    total_triplets = n * (n - 1) * (n - 2) // 6
    
    invalid_triplets = 0
    for size in subsets_sizes.values():
        if size >= 3:
            invalid_triplets += size * (size - 1) * (size - 2) // 6
        if size >= 2:
            invalid_triplets += size * (size - 1) // 2 * (n - size)
    
    valid_triplets = total_triplets - invalid_triplets
    return valid_triplets % (10**9 + 7)

n = int(input().strip())
edges = []
for _ in range(n - 1):
    u, v, color = input().strip().split()
    edges.append((int(u), int(v), color))

print(solve(edges))

from decimal import Decimal
class DisjointSet:
    def __init__(self):
        self.parent=self
        self.size=1
    def findParent(self):
        if self.parent!=self:
            self.parent=self.parent.findParent()
        return self.parent
    def union(self,other):
        if self==other:
            return
        root=self.findParent()
        other_root=other.findParent()
        if root==other_root:
            return
        if root.size>other_root.size:
            other_root.parent=root
            root.size+=other_root.size
        else:
            root.parent=other_root
            other_root.size+=root.size
def nc2(n):
    if n<2:
        return 0
    return Decimal(n*(n-1)/2)
def nc3(n):
    if n<3:
        return 0
    return Decimal(n*(n-1)*(n-2)/6)

n=int(input())
components=[None]*n
for i in range(n-1):
    a,b,c=input().split()
    a=int(a)-1
    b=int(b)-1
    if c=='r':
        continue
    if not components[a]:
        components[a]=DisjointSet()
    if not components[b]:
        components[b]=DisjointSet()
    components[a].union(components[b])



uniqueComponents=set()
for x in components:
    if x:
        uniqueComponents.add(x.findParent())
valid_triplets=Decimal(nc3(n))

for x in uniqueComponents:
    valid_triplets-=nc3(x.size)
    valid_triplets-=nc2(x.size)*(n-x.size)
print(int(valid_triplets)%(10**9+7))

// Hackerrank 2022-06-15 task (GO) Kundu and Tree.txt
// Made clever wrong non-brute force solutions 6 days

package main

import (
	"fmt"
	"io/ioutil"
	"os"
)

func main() {
	// graph vertex red adjacency and black adjacency lists
	var ra, ba [][]int

	// stdin, parse, fill ra, ba
	bytes, err := ioutil.ReadAll(os.Stdin)
	if err != nil {
		panic(err)
	}
	var accu int
	var inDigits bool
	var n int
	var one int
	var two int
	for _, b := range bytes {
		if b >= 48 && b <= 57 {
			inDigits = true
			accu = accu*10 + int(b) - 48
		} else {
			if inDigits {
				one = two
				two = accu
				accu = 0
				inDigits = false
				if n == 0 {
					n = two
					// slot[0] is never used. Index [1..n].
					ra = make([][]int, n+1)
					ba = make([][]int, n+1)
					continue
				}
			}
			switch b {
			case byte('b'):
				ba[one] = append(ba[one], two)
				ba[two] = append(ba[two], one)
				break
			case byte('r'):
				ra[one] = append(ra[one], two)
				ra[two] = append(ra[two], one)
				break
			}
		}
	}

	// Discovered-After-Red Lists
	darl := make([][]bool, n+1)

	// Do BFS from each vertex
	for s := 1; s <= n; s++ {
		// discovered
		d := make([]bool, n+1)
		// discovered after red
		dar := make([]bool, n+1)
		// fifo
		f := make([]int, 0)
		// fifo after red
		far := make([]bool, 0)
		// queue the search key
		d[s] = true
		f = append(f, s)
		far = append(far, false)
		// run until dry
		for len(f) > 0 {
			// dequeue vertex
			v := f[0]
			f = f[1:]
			// dequeue after red?
			ar := far[0]
			far = far[1:]
			for _, u := range ba[v] {
				if !d[u] {
					d[u] = true
					dar[u] = ar
					f = append(f, u)
					far = append(far, ar)
				}
			}
			for _, u := range ra[v] {
				if !d[u] {
					d[u] = true
					dar[u] = true
					f = append(f, u)
					far = append(far, true)
				}
			}
		}
		darl[s] = dar
	}

	// test the selftest
	// good, caught it: darl[3][7] = !darl[7][3]
	// as a selftest, prove the symmetry of darl
	// for i := 1; i <= n; i++ {
	// 	if darl[i][i] {
	// 		fmt.Println("darl[i][i]")
	// 	}
	// 	for j := i + 1; j <= n; j++ {
	// 		if darl[i][j] != darl[j][i] {
	// 			fmt.Println("asym")
	// 		}
	// 	}
	// }

	// Okay, I brute-forced it to here. Now what?

	N := int64(0)
	for i := 1; i <= n; i++ {
		for j := i + 1; j <= n; j++ {
			if darl[i][j] {
				for k := j + 1; k <= n; k++ {
					if darl[i][k] && darl[j][k] {
						N++
					}
				}
			}
		}
	}
	fmt.Println(N)
}