using System;

using System.Linq;

public class Program

{

    public static void Main()

    {

        // Read node values

        var nodeValues = ReadNodeValues();

​

        // Read an adjacency matrix

        var adjacencyMatrix = ReadAdjacencyMatrix();

​

        // Compute the node scores

        var scores = CalculateScores(nodeValues, adjacencyMatrix);

​

        // Output the scores

        foreach (var score in scores)

        {

            Console.Write(score);

            Console.Write(' ');

        }

    }

    /// <summary>

    /// Reads node values.

    /// </summary>

    static int[] ReadNodeValues()

    {

        // TODO: implement reading from data1.txt here

        var input = "5 3 4 3 6 5 2 6 1 4 4 7";

​

        return input

            .Split()

            .Select(int.Parse)

            .ToArray();

    }

​

    /// <summary>

    /// Reads node relations.

    /// </summary>

    static byte[][] ReadAdjacencyMatrix()

    {

        // TODO: implement reading from data2.txt here

        var input = @"

0 1 0 1 0 0 0 0 0 0 0 0

0 0 1 0 0 0 0 0 0 0 0 0

0 0 0 0 0 1 0 0 0 0 0 0

0 0 0 0 1 0 0 0 0 0 0 0

0 0 0 0 0 1 0 0 0 0 0 0

0 0 0 0 0 0 1 0 1 1 0 0

0 0 0 0 0 0 0 1 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 1

0 0 0 0 0 0 0 0 0 0 0 1

0 0 0 0 0 0 0 0 0 0 1 0

0 0 0 0 0 0 0 0 0 0 0 1

0 0 0 0 0 0 0 0 0 0 0 0

";

​

        var rows = input

            .Split(new[] { '\r', '\n'}, StringSplitOptions.RemoveEmptyEntries);

​

        var matrix = rows

            .Select(row => row

                .Split()

                .Select(byte.Parse)

                .ToArray()

            )

            .ToArray();

​

        return matrix;

    }

​

    /// <summary>

    /// Computes scores for the given nodes and their relations.

    /// </summary>

    static int[] CalculateScores(int[] nodeValues, byte[][] adjacencyMatrix)

    {

        var nodesCount = nodeValues.Length;

​

        // Create an empty array for node scores.

        var scores = new int[nodesCount];

​

        // Compute a matrix of affected nodes.

        var affectedNodeMatrix = BuildAffectedNodeMatrix(adjacencyMatrix);

​

        // For each node, compute its score

        for (var i = 0; i < nodesCount; i++)

        {

            // Initialize the score with the current node value

            var score = nodeValues[i];

​

            // Get nodes affected by the current one.

            var affectedNodes = affectedNodeMatrix[i];

​

            // Sum values of the affected nodes.

            for (int j = 0; j < nodesCount; j++)

            {

                if(affectedNodes[j] == 1)

                {

                    score += nodeValues[j];

                }

            }

​

            // Set the score to the result array.

            scores[i] = score;

        }

​

        return scores;

    }

​

    /// <summary>

    /// Builds a matrix, each element of which shows

    /// if a node with `row_index` "affects" a node with `col_index`.

    /// </summary>

    static byte[][] BuildAffectedNodeMatrix(byte[][] adjacencyMatrix)

    {

        var nodesCount = adjacencyMatrix.Length;

​

        // Create an empty matrix for the affected nodes.

        var affectedNodeMatrix = new byte[nodesCount][];

​

        // Iterate through all nodes, and compute their affected nodes.

        // One iteration builds affected nodes for the whole subgraph.

        for (int i = 0; i < nodesCount; i++)

        {

            BuildAffectedNodesForNode(i, adjacencyMatrix, affectedNodeMatrix);

        }

​

        return affectedNodeMatrix;

    }

​

    /// <summary>

    /// Builds an array of affected nodes for a specific node.

    /// </summary>

    static byte[] BuildAffectedNodesForNode(int nodeIndex, byte[][] adjacencyMatrix, byte[][] affectedNodeMatrix)

    {

        var affectedNodes = affectedNodeMatrix[nodeIndex];

        if (affectedNodes != null)

        {

            // Affected nodes for the current node have already been built.

            return affectedNodes;

        }

​

        // Get the adjacent nodes of the current node.

        var adjacentNodes = adjacencyMatrix[nodeIndex];

​

        // Create an empty array for affected nodes,

        // save it into the matrix.

        affectedNodes = new byte[adjacentNodes.Length];

        affectedNodeMatrix[nodeIndex] = affectedNodes;

​

        // Traverse through adjacent nodes and their affected nodes.

        for (var i = 0; i < adjacentNodes.Length; i++)

        {

            if (adjacentNodes[i] == 1)

            {

                // If the node is already marked as affected,

                // there is no need to traverse this subgraph.

                if(affectedNodes[i] == 1)

                {

                    continue;

                }

​

                // Set the adjacent node as affected one.

                affectedNodes[i] = 1;

​

                // Get the adjacent node's affected nodes.

                var adjacentAffectedNodes = BuildAffectedNodesForNode(i, adjacencyMatrix, affectedNodeMatrix);

​

                // Copy them to the current nodes' affected nodes.

                for (int j = 0; j < adjacentAffectedNodes.Length; j++)

                {

                    if(adjacentAffectedNodes[j] == 1)

                    {

                        affectedNodes[j] = 1;

                    }

                }

            }

        }

​

        return affectedNodes;

    }

}