// Reads multiple ints in a line, separate by a space.
// It works even if the actual number of ints is smaller than n.
// WARNING: This function does not work for -2^31.
// NOTE: This function does not handle error cases.
fun fastReadInts(n: Int): IntArray {
  val xs = IntArray(n)
  val s = readLine()!!
  var currentValue = 0
  var isNegative = false
  var currentIndex = 0
  for (c in s) {
    if (c == ' ') {
      xs[currentIndex] = currentValue * if (isNegative) -1 else 1
      currentValue = 0
      isNegative = false
      currentIndex++
    } else if (c == '-') {
      isNegative = true
    } else {
      currentValue *= 10
      currentValue += c - '0'
    }
  }
  xs[currentIndex] = currentValue * if (isNegative) -1 else 1
  return xs
}

// Implements Union-Find Set.
// Manages integers of [0, n).
class UFSet(n: Int) {
  private var ranks = IntArray(n, { 1 })
  private var prevs = IntArray(n, { it })

  // Returns a root of a tree which x belongs to.
  // The argument x needs to be in [0, n).
  fun find(x: Int): Int {
    if (x != prevs[x]) prevs[x] = find(prevs[x])
    return prevs[x]
  }

  // Merges a set which x belongs to and a set which y belongs to.
  // The argument x and y need to be in [0, n).
  fun union(x: Int, y: Int) {
    val xRoot = find(x)
    val yRoot = find(y)
    when {
      ranks[xRoot] > ranks[yRoot] -> prevs[yRoot] = prevs[xRoot]
      ranks[xRoot] < ranks[yRoot] -> prevs[xRoot] = prevs[yRoot]
      prevs[xRoot] != prevs[yRoot] -> {
        prevs[yRoot] = prevs[xRoot]
        ranks[xRoot]++
      }
    }
  }
}

data class Edge(val v1: Int, val v2: Int, val weight: Long)

sealed class TreeNode(val size: Int, var value: Long) {
  class InternalNode(val child1: TreeNode, val child2: TreeNode,
                     size: Int, value: Long): TreeNode(size, value)
  class LeafNode(val leafIndex: Int, size: Int, value: Long): TreeNode(size, value)
}

fun makeLeafNode(leafIndex: Int) = TreeNode.LeafNode(leafIndex, 1, 0)

fun makeParentNode(child1: TreeNode, child2: TreeNode) =
    TreeNode.InternalNode(child1, child2, child1.size + child2.size, 0)

fun main(args: Array<String>) {
  val n = readLine()!!.toInt()
  val edges = mutableListOf<Edge>()
  repeat(n - 1) {
    val (v1Raw, v2Raw, w) = fastReadInts(3)
    val v1 = v1Raw - 1
    val v2 = v2Raw - 1
    edges.add(Edge(v1, v2, w.toLong()))
  }
  edges.sortByDescending { it.weight }

  val ufSet = UFSet(n)
  val componentToTreeNode = Array<TreeNode>(n, { makeLeafNode(it) })

  for (edge in edges) {
    val v1 = edge.v1
    val v2 = edge.v2
    val c1 = ufSet.find(v1)
    val c2 = ufSet.find(v2)
    val node1 = componentToTreeNode[c1]
    val node2 = componentToTreeNode[c2]
    node1.value += node2.size * edge.weight
    node2.value += node1.size * edge.weight
    val parentNode = makeParentNode(node1, node2)
    ufSet.union(v1, v2)
    val cMerged = ufSet.find(v1)
    componentToTreeNode[cMerged] = parentNode
  }

  val rootNode = componentToTreeNode[ufSet.find(0)]
  val answerValues = LongArray(n)
  fun dfs(node: TreeNode, value: Long) {
    when (node) {
      is TreeNode.LeafNode -> {
        answerValues[node.leafIndex] = value + node.value
      }
      is TreeNode.InternalNode -> {
        dfs(node.child1, value + node.value)
        dfs(node.child2, value + node.value)
      }
    }
  }
  dfs(rootNode, 0)
  println(answerValues.joinToString("\n"))
}
