*n* fish, numbered from 1 to *n*, live in a lake. Every day right one pair of fish meet, and the probability of each other pair meeting is the same. If two fish with indexes i and j meet, the first will eat up the second with the probability *a*<sub class="lower-index">*ij*</sub>, and the second will eat up the first with the probability *a*<sub class="lower-index">*ji*</sub> = 1 - *a*<sub class="lower-index">*ij*</sub>. The described process goes on until there are at least two fish in the lake. For each fish find out the probability that it will survive to be the last in the lake.
The first line contains integer *n* (1 ≤ *n* ≤ 18) — the amount of fish in the lake. Then there follow *n* lines with *n* real numbers each — matrix *a*. *a*<sub class="lower-index">*ij*</sub> (0 ≤ *a*<sub class="lower-index">*ij*</sub> ≤ 1) — the probability that fish with index *i* eats up fish with index *j*. It's guaranteed that the main diagonal contains zeros only, and for other elements the following is true: *a*<sub class="lower-index">*ij*</sub> = 1 - *a*<sub class="lower-index">*ji*</sub>. All real numbers are given with not more than 6 characters after the decimal point.
2
0 0.5
0.5 0
0.500000 0.500000 
4
0 0.5 0.5 0.5
0.5 0 0.5 0.5
0.5 0.5 0 0.5
0.5 0.5 0.5 0
0.250000 0.250000 0.250000 0.250000 
5
0 1 1 1 1
0 0 0.5 0.5 0.5
0 0.5 0 0.5 0.5
0 0.5 0.5 0 0.5
0 0.5 0.5 0.5 0
1.000000 0.000000 0.000000 0.000000 0.000000 
1
0.000
1.000000 
2
0.000 0.551
0.449 0.000
0.551000 0.449000 
3
0.000 0.817 0.584
0.183 0.000 0.665
0.416 0.335 0.000
0.564400 0.208967 0.226632 
4
0.000 0.083 0.548 0.503
0.917 0.000 0.395 0.144
0.452 0.605 0.000 0.991
0.497 0.856 0.009 0.000
0.163512 0.222554 0.463543 0.150390 
5
0.000 0.349 0.202 0.088 0.431
0.651 0.000 0.435 0.627 0.564
0.798 0.565 0.000 0.725 0.949
0.912 0.373 0.275 0.000 0.027
0.569 0.436 0.051 0.973 0.000
0.059303 0.233839 0.494324 0.093917 0.118617 
8
0.000 0.147 0.783 0.224 0.220 0.651 0.453 0.209
0.853 0.000 0.246 0.076 0.018 0.349 0.896 0.315
0.217 0.754 0.000 0.307 0.968 0.400 0.531 0.086
0.776 0.924 0.693 0.000 0.707 0.842 0.116 0.949
0.780 0.982 0.032 0.293 0.000 0.908 0.307 0.266
0.349 0.651 0.600 0.158 0.092 0.000 0.066 0.909
0.547 0.104 0.469 0.884 0.693 0.934 0.000 0.251
0.791 0.685 0.914 0.051 0.734 0.091 0.749 0.000
0.056312 0.054963 0.091124 0.315966 0.093803 0.056812 0.187952 0.143068 
# By the grace of Goddess Saraswati and Durga#
# Author: Vaibhav Tiwari #


import os, sys, math
from io import BytesIO, IOBase


def main():
    n = int(input())
    prob = []
    for i in range(n):
        prob.append(arrin(float))
    FishBitmaskIterative(n,prob)


# Fast IO Region
BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
arrin = lambda x: list(map(x,input().split()))


# really showed me how state transition is magic.
def maximumSumOneDeletionAtmost(self, nums):
    pos = False
    for i in nums:
        if i > 0:
            pos = True
    if not pos: return max(nums)
    dp = {}
    mx = -1000000000
    dp[(0, 0)] = nums[0]
    dp[(0, 1)] = 0
    for i in range(1, len(nums)):
        dp[(i, 0)] = max(nums[i], nums[i] + dp[(i - 1, 0)])
        dp[(i, 1)] = max(nums[i] + dp[i - 1, 1], dp[i - 1, 0])
        mx = max(mx, dp[i, 1], dp[i, 0])
    return max(mx, dp[0, 0], dp[0, 1])


def onesComplement(n):
    # Find number of bits in
    # the given integer
    number_of_bits = (int)(math.floor(math.log(n) /
                                      math.log(2))) + 1;

    # XOR the given integer with poe(2,
    # number_of_bits-1 and print the result
    return ((1 << number_of_bits) - 1) ^ n;

def FishBitmaskIterative(n, prob):
    #0 in mask means fish alive
    #1 in bitmask means fish dead
    dp = [0 for _ in range(1<<n)]
    dp[0] = 1
    for mask in range(1<<n):
        alive_in_the_stage_before = n - bin(mask).count("1") + 1
        choosing_two = alive_in_the_stage_before*(alive_in_the_stage_before-1)/2
        for alive in range(n):
            if not mask & 1<<alive:
                for dead in range(n):
                    if mask & 1<<dead:
                        dp[mask] +=(dp[mask ^ 1<<dead]*prob[alive][dead]/choosing_two)
    ma = 1<<n
    ans = []
    for i in range(n):
        ans.append(dp[ma - 1 - (1 << i)])
    print(*ans)
if __name__ == "__main__":
    main()
