using System;

using System.Collections;

using System.Collections.Generic;

public class Program

{   //https://careercup.com/question?id=5695046734053376

    /*

        // preprocess your input graph to the following structure

// node -> hash set of neighbors

// hash set to enable amortized O(1) deletions 

vector<unordered_set<int>> topology(n);

vector<int> metadata(n); // contains the population count

vector<int> current_leaf_set;

int global_sum = 0;

for each node id i in topology{

    if(topology[i].size() == 1 ) current_leaf_set.push_back(i);

    global_sum += metadata[i];

}

int i = 0;

vector<int> sum(n), max(n); // initialize them to zero

while(i < current_leaf_set.size()){

        int node_id = current_leaf_set[i++];

    std::cout << node_id << " : " << (std::max( max[node_id], global_sum - metadata[node_id] - sum[node_id] )) << "\n";

    if( topology[node_id].size() == 0 ) continue; // Thanks @helloru

        int next_node = *(topology[node_id].begin()); // will only have one neighbor

    sum[next_node] += ( metadata[node_id] + sum[node_id]);

    max[next_node] = std::max( max[next_node], ( metadata[node_id] + sum[node_id]) );

    topology[next_node].erase(node_id);

    if( topology[next_node].size() == 1 ) current_leaf_set.push_back(next_node);

}

    */

    public static void Main()

    {

        Console.WriteLine("Hello World");

    }

    public static void PrintMaxTraffic(Graph g) {

        Queue<Node> q = new Queue<Node>();

        int totalSum = 0;

        for(int i =0; i < g.nodes.Count; i++) {

            if (g.nodes[i].neighbors.Count == 1) 

                q.Enqueue(g.nodes[i]);

            totalSum += g.nodes[i].population;

        }

        while(q.Count > 0) {

            Node n = q.Dequeue();

            Console.WriteLine("{0}: {1}", n.population, Math.Max(n.max, totalSum - n.population - n.sum));

            if (n.neighbors.Count == 0) continue;

            Node next = null;

            IEnumerator e = n.neighbors.GetEnumerator();

            e.MoveNext();

            next = (Node)e.Current;

            next.sum += n.population + n.sum;

            next.max = Math.Max(next.max, n.population + n.sum);

            next.neighbors.Remove(n);

            if (next.neighbors.Count == 1) q.Enqueue(next);

        }

    }

    public class Graph {

        public List<Node> nodes;

    }

    public class Node {

        public int population;

        public HashSet<Node> neighbors;

        public int sum;

        public int max;

    }

}