import java.io.*;
import java.math.*;
import java.util.*;

public class Main {

    InputReader input;
    PrintWriter output;

    void run(){
        output = new PrintWriter(new OutputStreamWriter(System.out));
        input = new InputReader(System.in);
        solve();
        output.flush();
    }

    public static void main(String[] args){
        new Main().run();
    }

    boolean isBitSet(int mask, int i) {
        return (mask&(1<<i)) != 0;
    }

    int unSet(int mask, int i) {
        return mask & ~(1<<i);
    }

    void solve() {
        int n = input.ni();
        double[][] prb = new double[n][n];
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                prb[i][j] = input.readDouble();
            }
        }
        double[] dp = new double[1<<n];
        dp[0] = 1.0;
        for(int i = 0; i < 1<<n; i++) {
            int remaining = n-Integer.bitCount(i);
            double remainingProbability = remaining*(remaining-1)/2;
            for(int j = 0; j < n; j++) {
                if(!isBitSet(i, j)) {   //jth fish is alive
                    for(int k = 0; k < n; k++) {    //candidates to kill jth fish
                        if(!isBitSet(i, k))
                            dp[i|(1<<j)] += dp[i]*prb[k][j]/(remainingProbability);
                    }
                }
            }
        }
        for(int i = 0; i < n; i++) {
            output.printf("%.7f ",dp[unSet((1<<n)-1, i)]);
        }
        output.println();
    }

    class InputReader {
        private boolean finished = false;
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
                this.stream = stream;
        }

        public int read() {
                if (numChars == -1)
                        throw new InputMismatchException();
                if (curChar >= numChars) {
                        curChar = 0;
                        try {
                                numChars = stream.read(buf);
                        } catch (IOException e) {
                                throw new InputMismatchException();
                        }
                        if (numChars <= 0)
                                return -1;
                }
                return buf[curChar++];
        }

        public int peek() {
                if (numChars == -1)
                        return -1;
                if (curChar >= numChars) {
                        curChar = 0;
                        try {
                                numChars = stream.read(buf);
                        } catch (IOException e) {
                                return -1;
                        }
                        if (numChars <= 0)
                                return -1;
                }
                return buf[curChar];
        }

        public int ni() {
                int c = read();
                while (isSpaceChar(c))
                        c = read();
                int sgn = 1;
                if (c == '-') {
                        sgn = -1;
                        c = read();
                }
                int res = 0;
                do {
                        if (c < '0' || c > '9')
                                throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                } while (!isSpaceChar(c));
                return res * sgn;
        }

        public long nl() {
                int c = read();
                while (isSpaceChar(c))
                        c = read();
                int sgn = 1;
                if (c == '-') {
                        sgn = -1;
                        c = read();
                }
                long res = 0;
                do {
                        if (c < '0' || c > '9')
                                throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                } while (!isSpaceChar(c));
                return res * sgn;
        }

        public String ns() {
                int c = read();
                while (isSpaceChar(c))
                        c = read();
                StringBuilder res = new StringBuilder();
                do {
                        res.appendCodePoint(c);
                        c = read();
                } while (!isSpaceChar(c));
                return res.toString();
        }

        public boolean isSpaceChar(int c) {
                if (filter != null)
                        return filter.isSpaceChar(c);
                return isWhitespace(c);
        }

        public boolean isWhitespace(int c) {
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        private String readLine0() {
                StringBuilder buf = new StringBuilder();
                int c = read();
                while (c != '\n' && c != -1) {
                        if (c != '\r')
                                buf.appendCodePoint(c);
                        c = read();
                }
                return buf.toString();
        }

        public String readLine() {
                String s = readLine0();
                while (s.trim().length() == 0)
                        s = readLine0();
                return s;
        }

        public String readLine(boolean ignoreEmptyLines) {
                if (ignoreEmptyLines)
                        return readLine();
                else
                        return readLine0();
        }

        public BigInteger readBigInteger() {
                try {
                        return new BigInteger(ns());
                } catch (NumberFormatException e) {
                        throw new InputMismatchException();
                }
        }

        public char readCharacter() {
                int c = read();
                while (isSpaceChar(c))
                        c = read();
                return (char) c;
        }

        public double readDouble() {
                int c = read();
                while (isSpaceChar(c))
                        c = read();
                int sgn = 1;
                if (c == '-') {
                        sgn = -1;
                        c = read();
                }
                double res = 0;
                while (!isSpaceChar(c) && c != '.') {
                        if (c == 'e' || c == 'E')
                                return res * Math.pow(10, ni());
                        if (c < '0' || c > '9')
                                throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                }
                if (c == '.') {
                        c = read();
                        double m = 1;
                        while (!isSpaceChar(c)) {
                                if (c == 'e' || c == 'E')
                                        return res * Math.pow(10, ni());
                                if (c < '0' || c > '9')
                                        throw new InputMismatchException();
                                m /= 10;
                                res += (c - '0') * m;
                                c = read();
                        }
                }
                return res * sgn;
        }

        public boolean eof() {
                int value;
                while (isSpaceChar(value = peek()) && value != -1)
                        read();
                return value == -1;
        }

        public String next() {
                return ns();
        }

        public SpaceCharFilter getFilter() {
                return filter;
        }

        public void setFilter(SpaceCharFilter filter) {
                this.filter = filter;
        }

    }
     public interface SpaceCharFilter {
         public boolean isSpaceChar(int ch);
     }

}


import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
static double p[][];
    static double dp[];
    static int n;

    public static int BitCount(int u) {
        int uCount;

        uCount = u - ((u >> 1) & 033333333333) - ((u >> 2) & 011111111111);
        return ((uCount + (uCount >> 3)) & 030707070707) % 63;
    }

    public static double f(int mask) {
        if (dp[mask] > -0.5)
            return dp[mask];

        dp[mask] = 0;

        int ones = BitCount(mask);
        double pairs = (((ones * (ones + 1))) >> 1);
        //System.out.println(pairs);

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if ((mask & (1 << i)) != 0 && (mask & (1 << j)) == 0)
                    dp[mask] += f(mask | (1 << j)) * p[i][j] / pairs;
            }
        }

        return dp[mask];
    }

    public static void main(String[] args) throws NumberFormatException,
            IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        n = Integer.parseInt(bf.readLine());
        p = new double[n][n];
        for (int i = 0; i < n; i++) {
            StringTokenizer st = new StringTokenizer(bf.readLine());
            for (int j = 0; j < n; j++) {
                p[i][j] = Double.parseDouble(st.nextToken());
            }
        }

        dp = new double[1 << n];

        Arrays.fill(dp, -1.0);

        dp[(1 << n) - 1] = 1.;

        for (int i = 0; i < n - 1; i++) {
            System.out.print(f(1 << i) + " ");
        }

        System.out.println(f((1 << (n - 1))));

    }
}


/**
 * Codeforces Beta Round 16
 *
 * @author ProjectYoung
 */

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class CF16E {
  private void solve(InputReader in, PrintWriter out) {
    int n = in.nextInt();
    double[][] prob = new double[n][n];
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        prob[i][j] = in.nextDouble();
      }
    }
    int[] fish = new int[n];
    for (int i = 0; i < n; i++) {
      fish[i] = 1 << i;
    }

    double[] res = new double[1 << n];
    res[0] = 1.0;
    for (int mask = 1; mask < (1 << n) - 1; mask++) {
      for (int i = 0; i < n; i++) {
        if ((mask & fish[i]) == 0) {
          continue;
        }
        int lastMask = mask ^ fish[i];
        int live = n;
        for (int j = 0; j < n; j++) {
          if ((lastMask & fish[j]) != 0) {
            live--;
          }
        }
        double p = 0.0;
        for (int j = 0; j < n; j++) {
          if ((lastMask & fish[j]) != 0 || j == i) {
            continue;
          }
          p += prob[j][i];
        }
        res[mask] += res[lastMask] * p * 2 / live / (live - 1);
      }
    }
    for (int i = 0; i < n; i++) {
      out.printf("%.6f ", res[((1 << n) - 1) ^ fish[i]]);
    }
  }

  public static void main(String[] args) {
    InputReader in = new InputReader(System.in);
    PrintWriter out = new PrintWriter(System.out);
    new CF16E().solve(in, out);
    out.close();
  }

  static class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
      reader = new BufferedReader(new InputStreamReader(stream), 32768);
      tokenizer = null;
    }

    public String next() {
      while (tokenizer == null || !tokenizer.hasMoreTokens()) {
        try {
          tokenizer = new StringTokenizer(reader.readLine());
        } catch (IOException e) {
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }

    public int nextInt() {
      return Integer.parseInt(next());
    }

    public double nextDouble() {
      return Double.parseDouble(next());
    }
  }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
	static int n, exp;
	static double arr[][],dp[], dies[][];
	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		n = new Integer(br.readLine());
		arr = new double[n][n];
		StringTokenizer st;
		for (int i = 0; i < n; i++) {
			st = new StringTokenizer(br.readLine());
			for (int j = 0; j < n; j++) {
				arr[i][j] = Double.parseDouble(st.nextToken());
			}
		}
		exp = 1<<n;
		dp = new double[exp];
		dies = new double[n][exp];
		for (int all = 0; all < exp; all++) {
			dp[all] = -1;
			int countAlive = 0;
			for (int i = 0; i < n; i++) {
				if((all&(1<<i))!=0)
					countAlive++;
			}
			if(countAlive <2)continue;
			double x=1.0/(countAlive*(countAlive-1)/2.0);
			for(int i=0; i<n; i++){
				dies[i][all]=0;
				int mask=1<<i;
				if((mask&all)>0){
					for(int j=0; j<n; j++)
					{
						int mask2=1<<j;
						if((mask2&all)>0)
							dies[i][all]+=arr[j][i];
					}
					dies[i][all]*=x;
				}
			}
		}
		for(int myFish=0; myFish<n; myFish++){
			if(myFish>0)System.out.printf(" ");
			System.out.printf("%.6f",ff(1<<myFish));
		}
		System.out.println();

	}
	static double ff(int state){
		if(state==exp-1)return 1;
		if(dp[state]!=-1)return dp[state];
		double ans=0;
		for(int i=0; i<n; i++)
		{
			int mask=1<<i;
			if((mask &state)==0)
			{
				ans+=dies[i][state+mask]*ff(state+mask);
			}
		}
		return dp[state]=ans;
	}

}


import java.util.Locale;
import java.util.Scanner;

public class E {

    public static void main(String[] args) {
        Locale.setDefault(Locale.US);
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        double[][]p = new double[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                p[i][j] = sc.nextDouble();
            }
        }
        double[]dp = new double[1<<n];
        dp[(1 << n)-1] = 1;
        for (int mask = (1 << n)-1; mask > 0; mask--) {
            int t = Integer.bitCount(mask);
            if (t==1)
                continue;
            double p0 = 1.0/(t*(t-1)/2);
            for (int i = 0; i < n; i++) {
                if ((mask & (1 << i)) != 0) {
                    for (int j = 0; j < n; j++) {
                        if (j != i && (mask & (1 << j)) != 0)
                            dp[(mask ^ (1 << i))] += dp[mask] * p[j][i]*p0;
                    }
                }
            }
        }
        for (int i = 0; i < n; i++) {
            System.out.print(dp[1 << i]+" ");
        }
    }
}


import java.io.*;
import java.util.*;
import java.math.*;
import java.util.regex.*;

/**
 *
 * @author jon
 */
public class Fish {
    double memo[] = new double[(1<<18)];
    int N, FULL;
    double prob[][] = new double[18][18];
    Fish() {
        Scanner in = new Scanner(System.in);
        Arrays.fill(memo, -1);

        N = in.nextInt();
        FULL = (1<<N) - 1;

        for(int i = 0; i < N; i++) {
            for(int j = 0; j < N; j++) {
                prob[i][j] = in.nextDouble();
            }
        }

        for(int i = 0; i < N; i++) {
            System.out.printf("%.6f ", go((1<<i)));
        }
        System.out.println();

    }
    public double go(int mask) {
        if(mask == FULL) return 1.0;
        if(memo[mask] >= 0) return memo[mask];
        double ret = 0;
        double mult = Integer.bitCount(mask) + 1;
        mult *= (mult-1)/2.0;
//        double k = getBits(mask);
//        System.out.println(k + " " + mult);
//        k *= (k-1)/2.0;

        for(int i = 0; i < N; i++) {
            if(((1<<i) & mask) != 0) {
                for(int j = 0; j < N; j++) {
                    if(((1<<j) & mask) == 0) {
                        ret += go(mask | (1<<j)) * prob[i][j] / mult;
                    }
                }
            }
        }
        //ret /= (double)mult;

        memo[mask] = ret;
        return ret;
    }
  private int getBits(int x){
    int cnt = 0;
    while(x > 0){
      x&=(x-1);
      cnt++;
    }
    return cnt+1;
  }
    public static void main(String args[]) {
        new Fish();
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Arrays;
import java.util.Locale;

public class E16 {

	static StreamTokenizer in;
	static PrintWriter out;

	static int nextInt() throws IOException {
		in.nextToken();
		return (int)in.nval;
	}

	static double nextDouble() throws IOException {
		in.nextToken();
		return in.nval;
	}

	static String nextString() throws IOException {
		in.nextToken();
		return in.sval;
	}

	public static void main(String[] args) throws IOException {
		in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		out = new PrintWriter(System.out);

		n = nextInt();
		t = 1 << n;
		m = new double[n][n];
		for (int i = 0; i < n; i++)
			for (int j = 0; j < n; j++)
				m[i][j] = nextDouble();

		memo = new double[t];
		Arrays.fill(memo, Double.POSITIVE_INFINITY);
		for (int i = 0; i < n; i++) out.print(String.format(Locale.US, "%.6f", solve(1 << i)) + " ");
		out.println();

		out.flush();
	}

	static int n, t;
	static double[][] m;
	static double[] memo;

	static double solve(int mask) {
		if (memo[mask] != Double.POSITIVE_INFINITY) return memo[mask];
		if (mask == t-1) return memo[mask] = 1;

		int k = Integer.bitCount(mask);
		k = (k+1)*k/2;
		double res = 0;
		for (int i = 0; i < n; i++) if ((mask&(1 << i)) != 0)
			for (int j = 0; j < n; j++) if ((mask&(1 << j)) == 0)
				res += m[i][j]*solve(mask|(1 << j));

		return memo[mask] = res/k;
	}
}


import java.util.Arrays;
import java.util.Locale;
import java.util.Scanner;

public class Fish {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        in.useLocale(Locale.US);
        int n = in.nextInt();

        double[] dp = new double[1 << n];
        Arrays.fill(dp, 0);
        dp[(1 << n) - 1] = 1;//?

        double[][] prob = new double[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                prob[i][j] = in.nextDouble();
            }
        }

        for (int t = (1 << n) - 1; t >= 0; t--) {
            int k = Integer.bitCount(t);
            for (int i = 0; i < n; i++) {
                if ((t & (1 << i)) > 0) {
                    for (int j = 0; j < n; j++) {
                        if ((t & (1 << j)) > 0) {
                            if (i != j) {
                                dp[t - (1 << j)] += dp[t] * prob[i][j] / (k*(k-1)/2);
                            }
                        }
                    }
                }
            }
        }

        for (int i = 0; i < n; i++) {
            System.out.print(dp[1 << i] + " ");
        }
    }
}


import java.io.*;
import java.util.*;

public class CF16E {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int n = Integer.parseInt(br.readLine());
		double[][] aa = new double[n][n];
		for (int i = 0; i < n; i++) {
			StringTokenizer st = new StringTokenizer(br.readLine());
			for (int j = 0; j < n; j++)
				aa[i][j] = Double.parseDouble(st.nextToken());
		}
		double[][] pp = new double[1 << n][n];
		for (int k = 0; k < n; k++)
			pp[1 << k][k] = 1;
		for (int b = 1; b < 1 << n; b++) {
			int c = 0;
			for (int i = 0; i < n; i++) {
				if ((b & 1 << i) == 0)
					continue;
				c++;
				for (int j = i + 1; j < n; j++) {
					if ((b & 1 << j) == 0)
						continue;
					for (int k = 0; k < n; k++) {
						if ((b & 1 << k) == 0)
							continue;
						pp[b][k] += aa[i][j] * pp[b ^ 1 << j][k];
					 	pp[b][k] += aa[j][i] * pp[b ^ 1 << i][k];
					}
				}
			}
			if (c > 1) {
				double p = (double) c * (c - 1) / 2;
				for (int k = 0; k < n; k++)
					pp[b][k] /= p;
			}
		}
		StringBuilder sb = new StringBuilder();
		int b = (1 << n) - 1;
		for (int k = 0; k < n; k++)
			sb.append(pp[b][k]).append(k == n - 1 ? '\n' : ' ');
		System.out.print(sb);
	}
}


/*
	Author	:	Imran Khan
	Language:	Java

*/

import java.io.*;
import java.util.*;
public class Main
{
	public class BasicInputOutput
	{

		private StringTokenizer strtoken;
		private BufferedReader bufferReader;
		private BufferedWriter bufferWriter;
		private String delim = " \t\n\r\f";
		BasicInputOutput()
		{
			delim = " \t\n\r\f";
			initialize();
		}
		BasicInputOutput( String s )
		{
			delim = s;
			initialize();
		}
		private void initialize()
		{
			bufferReader = new BufferedReader( new InputStreamReader( System.in ));
			bufferWriter = new BufferedWriter( new PrintWriter( System.out ));
			strtoken = null;
		}
		private void checkStringTokenizer()throws IOException
		{
			if ( strtoken == null || strtoken.hasMoreTokens() == false )
				strtoken = new StringTokenizer( bufferReader.readLine(), delim );
		}
		public int getNextInt()throws IOException
		{
			checkStringTokenizer();
			return Integer.parseInt( strtoken.nextToken());
		}

		public long getNextLong()throws IOException
		{
			checkStringTokenizer();
			return Long.parseLong( strtoken.nextToken());
		}

		public double getNextDouble()throws IOException
		{
			checkStringTokenizer();
			return Double.parseDouble( strtoken.nextToken());
		}

		public float getNextFloat()throws IOException
		{
			checkStringTokenizer();
			return Float.parseFloat( strtoken.nextToken());
		}

		public String getNextString()throws IOException
		{
			checkStringTokenizer();
			return strtoken.nextToken();
		}

		public String getNextLine()throws IOException
		{
			checkStringTokenizer();
			return bufferReader.readLine();
		}

		public void skipCurrentLine()throws IOException
		{
			checkStringTokenizer();
			strtoken = null;
		}
		public void write( String var )throws IOException
		{
			bufferWriter.write( var );
		}

		public < T > void write( char sep, T... var )throws IOException
		{
			if ( var.length == 0 )
				return ;
			bufferWriter.write( var[0].toString());
			for ( int i = 1; i < var.length; i++ )
				bufferWriter.write( sep + var[i].toString());
		}

		public void flush()throws IOException
		{
			bufferWriter.flush();
		}
	}

	public static void main(String[] args)
	{
		try
		{
			new Main().run();
		}
		catch (Exception ex)
		{
			ex.printStackTrace();
		}
	}
	private BasicInputOutput iohandler;
	private int n;
	private double[][] mat;
	private double[][] sum;
	private double[] dp;
	private int tolive;
	private void run()throws Exception
	{
		initialize();
		solve();
	}
	private void initialize() throws Exception
	{
		iohandler=new BasicInputOutput();
		n=iohandler.getNextInt();
		mat=new double[n][n];
		sum=new double[(1<<n)+10][n];
		dp=new double[1<<n];
		for(int i=0;i<n;i++) for(int j=0;j<n;j++)
		{
			mat[i][j]=iohandler.getNextDouble();
		}
	}
	private int bitCount(int mask)
	{
		int ret=0;
		while(mask>0) {
			ret++;
			mask&=(mask-1);
		}
		return ret;
	}
	private void solve() throws Exception
	{
		double[] ans=new double[n];
		int ub=1<<n;
		for(int i=1;i<ub;i++) {
			for(int j=0;j<n;j++) {
				sum[i][j]=0;
				for(int k=0;k<n;k++) if ((i&(1<<k))!=0) sum[i][j]+=mat[k][j];
				int cntbit=bitCount(i);
				if (cntbit>1)
				sum[i][j]/=((double)cntbit*(cntbit-1.))/2.;
			}
		}
		for(int i=0;i<n;i++)
		{
			for(int mask=1;mask<ub;mask++) {
				dp[mask]=0;
				if ((mask&(1<<i))==0) continue;
				if (bitCount(mask)==1)
				{
					dp[mask]=1.;
				} else
				for(int k=0;k<n;k++) {
					if ((mask&(1<<k))==0) continue;
					if (i==k) continue;
					dp[mask]+=sum[mask][k]*dp[mask-(1<<k)];
				}
			}
			ans[i]=dp[ub-1];
		}
		iohandler.write(ans[0]+"");
		for(int i=1;i<n;i++) iohandler.write(" "+ans[i]);
		iohandler.write("\n");
		iohandler.flush();
	}
}


import java.io.*;
public class Main
{
    static double arr[][];
    public static void main(String[] args)
    {
        try
        {
            Parserdoubt pd=new Parserdoubt(System.in);
            PrintWriter pw=new PrintWriter(System.out);
            int fishes=pd.nextInt();
            arr=new double[fishes][fishes];
            for(int i=0;i<fishes;i++)
                for(int j=0;j<fishes;j++)
                    arr[i][j]=Double.parseDouble(pd.nextString());
            double dp[]=new double[(1<<fishes)];
            dp[dp.length-1]=1.0;
            for(int c=dp.length-1;c>=0;c--)
            {
                int count=Integer.bitCount(c);
                if(count<=1)
                    continue;
                for(int i=0;i<fishes;i++)
                    for(int j=i+1;j<fishes;j++)
                    {
                        if(((1<<i)&c)!=0&&((1<<j)&c)!=0)
                        {
                            dp[c&~(1<<j)]+=arr[i][j]*dp[c];
                            dp[c&~(1<<i)]+=arr[j][i]*dp[c];
                        }
                    }
            }
            double s=0.0;
            for(int i=0;i<fishes;i++)
                s+=dp[1<<i];
            for(int i=0;i<fishes;i++)
                dp[1<<i]/=s;
            int i=0;
            for(i=0;i<fishes-1;i++)
                pw.printf("%.6f ",dp[1<<i]);
            pw.printf("%.6f\n",dp[1<<i]);
            pw.close();
        }
        catch(Exception e)
        {}
    }
}
class Parserdoubt
    {
       final private int BUFFER_SIZE = 1 << 17;

       private DataInputStream din;
       private byte[] buffer;
       private int bufferPointer, bytesRead;

       public Parserdoubt(InputStream in)
       {
          din = new DataInputStream(in);
          buffer = new byte[BUFFER_SIZE];
          bufferPointer = bytesRead = 0;
       }
       public String nextString() throws Exception
       {
           StringBuffer sb=new StringBuffer("");
           byte c = read();
           while (c <= ' ') c = read();
           do
           {
               sb.append((char)c);
               c=read();
           }while(c>' ');
           return sb.toString();
       }
       public char nextChar() throws Exception
       {
           byte c=read();
           while(c<=' ') c= read();
           return (char)c;
       }
       public int nextInt() throws Exception
       {
          int ret = 0;
          byte c = read();
          while (c <= ' ') c = read();
          boolean neg = c == '-';
          if (neg) c = read();
          do
          {
              ret = ret * 10 + c - '0';
             c = read();
          } while (c > ' ');
          if (neg) return -ret;
          return ret;
       }
       public long nextLong() throws Exception
       {
          long ret = 0;
          byte c = read();
          while (c <= ' ') c = read();
          boolean neg = c == '-';
          if (neg) c = read();
          do
          {
              ret = ret * 10 + c - '0';
             c = read();
          } while (c > ' ');
          if (neg) return -ret;
          return ret;
       }
       private void fillBuffer() throws Exception
       {
          bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
          if (bytesRead == -1) buffer[0] = -1;
       }

       private byte read() throws Exception
       {
          if (bufferPointer == bytesRead) fillBuffer();
          return buffer[bufferPointer++];
       }
    }


import java.io.*;
import java.util.*;
public class E16 {
	static double[][] grid;
	public static void main(String[] args) throws IOException	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int n = Integer.parseInt(br.readLine());
		grid = new double[n][n];
		for(int i = 0; i < n; i++)	{
			StringTokenizer st = new StringTokenizer(br.readLine());
			for(int j = 0; j < n; j++)	{
				grid[i][j] = Double.parseDouble(st.nextToken());
			}
		}
		boolean[] seen = new boolean[1<<n];
		double[] prob = new double[1<<n];
		prob[(1<<n)-1] = 1;
		LinkedList<Integer> q = new LinkedList<Integer>();
		q.add((1<<n)-1);
		while(!q.isEmpty())	{
			int curr = q.removeFirst();
			if(Integer.bitCount(curr) == 1)
				continue;
			for(int i = 0; i < n; i++)	{
				if((curr & (1 << i)) == 0)
					continue;
				for(int j = i+1; j < n; j++)		{
					if((curr & (1<<j)) == 0)
						continue;
					prob[curr-(1<<i)] += prob[curr] * grid[j][i];
					prob[curr-(1<<j)] += prob[curr] * grid[i][j];
					if(!seen[curr-(1<<i)])	{
						q.addLast(curr-(1<<i));
						seen[curr-(1<<i)] = true;
					}
					if(!seen[curr-(1<<j)])	{
						q.addLast(curr-(1<<j));
						seen[curr-(1<<j)] = true;
					}
				}
			}
			prob[curr] = 0;
		}
		double sum = 0;
		for(int i = 0; i < n; i++)		{
			sum += prob[1<<i];
		}
		for(int i = 0; i < n-1; i++)	{
			System.out.print(prob[1<<i]/sum + " ");
		}
		System.out.println(prob[1<<(n-1)]/sum);
	}
}


import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Problem {

	public static void main(String[] arg){
		FastScanner scan = new FastScanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int n = scan.nextInt();

		double ncr[][] = new double[n+1][n+1];
		ncr[1][0] = ncr[0][1] = ncr[1][1] = 1.0;
		for(int i = 2; i <= n; i++){
			for(int j = 0; j <= i; j++){
				if(j == 0 || j == i) ncr[i][j] = 1.0;
				else ncr[i][j] = ncr[i-1][j] + ncr[i-1][j-1];
				//System.out.print(ncr[i][j] + "  ");
			}
			//System.out.println();
		}

		double a[][] = new double[n+1][n+1];
		for(int i = 0; i < n; i++)
			for(int j = 0; j < n; j++)
				a[i][j] = scan.nextDouble();

		double dp[] = new double[1<<19];
		dp[(1<<n) - 1] = 1.0;
		for(int state = (1 << n) - 1; state >= 0; state--){
			int len = 0;
			for(int i = 0; i < n; i++)
				if((state & (1 << i)) > 0) len++;

			for(int i = 0; i < n; i++){
				if(((1 << i) & state) == 0) continue;
				for(int j = 0; j < i; j++){
					if(((1 << j) & state) == 0) continue;
					dp[state & (~(1<<i))] += (dp[state] * a[j][i] / ncr[len][2]);
					dp[state & (~(1<<j))] += (dp[state] * a[i][j] / ncr[len][2]);
					//System.out.println(state + " / " + (state & (~(1<<i))) + " / " + dp[state] + " / " + a[j][i] + " / " + (dp[state] * a[j][i]) + " / "  + dp[state & (~(1<<i))]);
					//System.out.println(state + " / " + (state & (~(1<<j))) + " / " + dp[state] + " / " + a[i][j] + " / " + (dp[state] * a[i][j]) + " / "  + dp[state & (~(1<<j))]);
					//System.out.println();
				}
			}
		}
		for(int i = 0; i < n; i++)
			System.out.print(String.format("%.6f", dp[1<<i]) + " ");
		out.close();
	}
	public static long gcd(long a, long b){
		if(b == 0) return a;
		if(a < b) return gcd(b, a);
		return gcd(b, a % b);
	}
	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		FastScanner(InputStream is) {
			try {
				br = new BufferedReader(new InputStreamReader(is));
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (Exception e) {
					return null;
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.valueOf(next());
		}
	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class A {

	static double[][] a;
	static int N;
	static double[] memo;

	static double dp(int alive)
	{
		int count = Integer.bitCount(alive);
		if(count == N)
			return 1;
		if(memo[alive] > -5)
			return memo[alive];

		double ret = 0;
		for(int j = 0; j < N; ++j)
			if((alive & (1<<j)) == 0)
				ret += die[j][alive | 1<<j] * dp(alive | 1<<j);

		return memo[alive] = ret;
	}

	static double[][] die;
	static void f()
	{
		die = new double[N][1<<N];
		for(int i = 0; i < N; ++i)
			for(int j = 0; j < 1<<N; ++j)
			{
				int count = Integer.bitCount(j);
				if(count <= 1)
					continue;
				double prop = 1.0 / (count * (count - 1) >> 1);
				for(int k = 0; k < N; ++k)
					if((j & (1<<k)) != 0)
						die[i][j] += prop * a[k][i];
			}

	}

	public static void main(String[] args) throws IOException {

		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);

		N = sc.nextInt();

		a = new double[N][N];
		for(int i = 0; i < N; ++i)
			for(int j = 0; j < N; ++j)
				a[i][j] = sc.nextDouble();
		memo = new double[1<<N];
		f();

		Arrays.fill(memo, -10);
		for(int i = 0; i < N - 1; ++i)
			out.printf("%.8f ", dp(1 << i));
		out.printf("%.8f\n", dp(1 << N - 1));

		out.flush();
		out.close();
	}

	static class Scanner
	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s){  br = new BufferedReader(new InputStreamReader(s));}

		public String next() throws IOException
		{
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public double nextDouble() throws NumberFormatException, IOException
		{
			return Double.parseDouble(next());
		}

		public int nextInt() throws IOException {return Integer.parseInt(next());}

		public long nextLong() throws IOException {return Long.parseLong(next());}

		public String nextLine() throws IOException {return br.readLine();}

		public boolean ready() throws IOException {return br.ready();}

	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Arrays;
import java.util.Locale;

public class E16 {

    static StreamTokenizer in;
    static PrintWriter out;

    static int nextInt() throws IOException {
        in.nextToken();
        return (int)in.nval;
    }

    static double nextDouble() throws IOException {
        in.nextToken();
        return in.nval;
    }

    static String nextString() throws IOException {
        in.nextToken();
        return in.sval;
    }

    public static void main(String[] args) throws IOException {
        in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        out = new PrintWriter(System.out);

        n = nextInt();
        t = 1 << n;
        m = new double[n][n];
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                m[i][j] = nextDouble();

        memo = new double[t];
        Arrays.fill(memo, Double.POSITIVE_INFINITY);
        for (int i = 0; i < n; i++) out.print(String.format(Locale.US, "%.6f", solve(1 << i)) + " ");
        out.println();

        out.flush();
    }

    static int n, t;
    static double[][] m;
    static double[] memo;

    static double solve(int mask) {
        if (memo[mask] != Double.POSITIVE_INFINITY) return memo[mask];
        if (mask == t-1) return memo[mask] = 1;

        int k = Integer.bitCount(mask);
        k = (k+1)*k/2;
        double res = 0;
        for (int i = 0; i < n; i++) if ((mask&(1 << i)) != 0)
            for (int j = 0; j < n; j++) if ((mask&(1 << j)) == 0)
                res += m[i][j]*solve(mask|(1 << j));

        return memo[mask] = res/k;
    }
}


import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.*;

public class ProblemE_16 {

    final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE")!=null;
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    void init() throws FileNotFoundException{
        if (ONLINE_JUDGE){
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }else{
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
    }

    String readString() throws IOException{
        while(!tok.hasMoreTokens()){
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException{
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException{
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException{
        return Double.parseDouble(readString());
    }

    public static void main(String[] args){
        new ProblemE_16().run();
    }

    public void run(){
        try{
            long t1 = System.currentTimeMillis();
            init();
            solve();
            out.close();
            long t2 = System.currentTimeMillis();
            System.err.println("Time = "+(t2-t1));
        }catch (Exception e){
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    void solve() throws IOException{
        int n = readInt();
        double[][] a = new double[n][n];
        for (int i = 0; i < n; i++){
            for (int j = 0; j < n; j++){
                a[i][j] = readDouble();
            }
        }
        double[] d = new double[1<<n];
        d[(1 << n) - 1] = 1;
        for (int i = (1 << n) - 1; i > 0; i--){
            ArrayList<Integer> list = new ArrayList<Integer>();
            for (int j = 0; j < n; j++){
                if ((i & (1 << j)) != 0) list.add(j);
            }
            double s = 0;
            for (int j = 0; j < list.size(); j++){
                s = 0;
                for (int k = 0; k < list.size(); k++){
                    s += a[list.get(k)][list.get(j)];
                }
                d[i ^ (1 << list.get(j))] += s * d[i] * 2 / list.size() / (list.size() - 1);
            }
        }
        for (int i = 0; i < n; i++){
            out.printf(Locale.US, "%.9f", d[1 << i]);
            out.print(" ");
        }
    }

    static int[][] step8 = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}, {-1, -1}, {1, -1}, {-1, 1}, {1, 1}};

    static int[][] stepKnight = {{-2, -1}, {-2, 1}, {-1, -2}, {-1, 2}, {1, -2}, {1, 2}, {2, -1}, {2, 1}};

    static long gcd(long a, long b){
        if (a == 0) return b;
        return gcd(b % a, a);
    }

    static long lcm(long a, long b){
        return a / gcd(a, b)*b;
    }

    static long[] gcdPlus(long a, long b){
        long[] d = new long[3];
        if (a == 0){
            d[0] = b;
            d[1] = 0;
            d[2] = 1;
        }else{
            d = gcdPlus(b % a, a);
            long r = d[1];
            d[1] = d[2] - b/a*d[1];
            d[2] = r;
        }
        return d;
    }

    static long binpow(long a, int n){
        if (n == 0) return 1;
        if ((n & 1) == 0){
            long b = binpow(a, n/2);
            return b*b;
        }else return binpow(a, n - 1)*a;
    }

    static long binpowmod(long a, int n, long m){
        if (m == 1) return 0;
        if (n == 0) return 1;
        if ((n & 1) == 0){
            long b = binpowmod(a, n/2, m);
            return (b*b) % m;
        }else return binpowmod(a, n - 1, m)*a % m;
    }

    static long phi(long n){
        int[] p = Sieve((int)ceil(sqrt(n)) + 2);
        long phi = 1;
        for (int i = 0; i < p.length; i++){
            long x = 1;
            while (n % p[i] == 0){
                n /= p[i];
                x *= p[i];
            }
            phi *= x - x/p[i];
        }
        if (n != 1) phi *= n - 1;
        return phi;
    }

    static long f(long n, int x, int k){ //Кол-во десятичных чисел (включая 0), содержащих в себе цифры от 0 до k-1
        if (n == 0) return 1;
        long b = binpow(10, x - 1);
        long c = n / b;
        return (c < k? c: k)*binpow(k, x - 1) + (c < k? 1: 0)*f(n % b, x - 1, k);
    }

    static long fib(int n){
        if (n == 0) return 0;
        if ((n & 1) == 0){
            long f1 = fib(n/2 - 1);
            long f2 = fib(n/2 + 1);
            return f2*f2 - f1*f1;
        }else{
            long f1 = fib(n/2);
            long f2 = fib(n/2 + 1);
            return f1*f1 + f2*f2;
        }
    }

    static BigInteger BigFib(int n){
        if (n == 0) return BigInteger.ZERO;
        if ((n & 1) == 0){
            BigInteger f1 = BigFib(n/2 - 1);
            f1 = f1.multiply(f1);
            BigInteger f2 = BigFib(n/2 + 1);
            f2 = f2.multiply(f2);
            return f2.subtract(f1);
        }else{
            BigInteger f1 = BigFib(n/2);
            f1 = f1.multiply(f1);
            BigInteger f2 = BigFib(n/2 + 1);
            f2 = f2.multiply(f2);
            return f2.add(f1);
        }
    }

    static public class PointD{

        double x, y;

        public PointD(double x, double y){
            this.x = x;
            this.y = y;
        }
    }

    static double d(Point p1, Point p2){
        return sqrt(d2(p1, p2));
    }

    static public double d(PointD p1, PointD p2){
        return sqrt(d2(p1, p2));
    }

    static double d2(Point p1, Point p2){
        return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);
    }

    static public double d2(PointD p1, PointD p2){
        return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);
    }

    static boolean IsProbablyPrime(long n){
        if (n == 1) return false;
        if ((n & 1) == 0) return false;
        for (int j = 3; j < sqrt(n) + 1; j += 2){
            if (n % j == 0) return false;
        }
        return true;
    }

    static int[] Sieve(int n){
        boolean[] b = new boolean[n+1];
        Arrays.fill(b, true);
        b[0] = false;
        b[1] = false;
        long nLong = n;
        int j=0;
        for (int i = 1; i <= n; i++) {
            if (b[i]){
                j++;
                if (((long)i)*i <= nLong) {
                    for (int k = i*i; k <= n; k += i) {
                        b[k] = false;
                    }
                }
            }
        }
        int[] p = new int[j];
        Arrays.fill(p, 0);
        j=0;
        for (int i = 2; i <= n; i++) {
            if (b[i]){
                p[j]=i;
                j++;
            }
        }
        return p;
    }

    static int[][] Palindromes(String s){
        char[] c = s.toCharArray();
        int n = c.length;
        int[][] d = new int[2][n];
        int l = 0, r = -1;
        for (int i = 0; i < n; i++){
            int j = (i > r? 0: min(d[0][l+r-i+1], r-i+1)) + 1;
            for (; i - j >= 0 && i + j - 1< n && c[i-j] == c[i+j-1]; j++);
            d[0][i] = --j;
            if (i + d[0][i] - 1 > r){
                r = i + d[0][i] - 1;
                l = i - d[0][i];
            }
        }
        l = 0;
        r = -1;
        for (int i = 0; i < n; i++){
            int j = (i > r? 0: min(d[1][l+r-i], r-i)) + 1;
            for (; i - j >= 0 && i + j < n && c[i-j] == c[i+j]; j++);
            d[1][i] = --j;
            if (i + d[1][i] > r){
                r = i + d[1][i];
                l = i - d[1][i];
            }
        }
        return d;
    }

    static public class Permutation {

        int[] a;
        int n;

        public Permutation(int n){
            this.n=n;
            a=new int[n];
            for (int i=0; i<n; i++){
                a[i]=i;
            }
        }

        public boolean nextPermutation(){ //Пишется с do{}while(nextPermutation(a));
            int i=n-1;
            for (i=n-2; i>=0; i--){
                if (a[i]<a[i+1]){
                    break;
                }
            }
            if (i==-1){
                return false;
            }
            int jMin=i+1;
            for (int j=n-1; j>i; j--){
                if (a[i]<a[j]&&a[j]<a[jMin]){
                    jMin=j;
                }
            }
            swap(i, jMin);
            for (int j=1; j<=(n-i)/2; j++){
                swap(i+j, n-j);
            }
            return true;
        }

        public int get(int i){
            return a[i];
        }

        void swap(int i, int j){
            int r=a[i];
            a[i]=a[j];
            a[j]=r;
        }
    }

    static public class Fraction implements Comparable<Fraction>, Cloneable{

        public final Fraction FRACTION_ZERO = new Fraction();
        public final Fraction FRACTION_ONE = new Fraction(1);
        public long numerator = 0;
        public long denominator = 1;

        public Fraction(){
            numerator = 0;
            denominator = 1;
        }

        public Fraction(long numerator){
            this.numerator = numerator;
            denominator = 1;
        }

        public Fraction(long numerator, long denominator){
            this.numerator = numerator;
            this.denominator = denominator;
            Cancellation();
        }

        public Fraction(double numerator, double denominator, int accuracy){
            this.numerator = (long)(numerator*pow(10,accuracy));
            this.denominator = (long)(denominator*pow(10,accuracy));
            Cancellation();
        }

        public Fraction(String s){
            if (s.charAt(0) == '-'){
                denominator = -1;
                s = s.substring(1);
            }
            if (s.indexOf("/") != -1){
                denominator *= Integer.parseInt(s.substring(s.indexOf("/") + 1));
            }
            if (s.indexOf(" ") != -1){
                numerator = Integer.parseInt(s.substring(0, s.indexOf(" "))) * abs(denominator) + Integer.parseInt(s.substring(s.indexOf(" ") + 1, s.indexOf("/")));
            }else{
                if (s.indexOf("/") != -1){
                    numerator = Integer.parseInt(s.substring(0, s.indexOf("/")));
                }else{
                    numerator = Integer.parseInt(s)*abs(denominator);
                }
            }
            this.Cancellation();
        }

        void Cancellation(){
            long g = gcd(abs(numerator), abs(denominator));
            numerator /= g;
            denominator /= g;
            if (denominator < 0){
                numerator *= -1;
                denominator *= -1;
            }
        }

        public String toString(){
            String s = "";
            if (numerator == 0){
                return "0";
            }
            if (numerator < 0){
                s += "-";
            }
            if (abs(numerator) >= denominator){
                s += Long.toString(abs(numerator) / denominator) + " ";
            }
            if (abs(numerator) % denominator != 0){
                s += Long.toString(abs(numerator) % denominator);
            }else{
                s = s.substring(0, s.length()-1);
            }
            if (denominator != 1){
                s += "/" + Long.toString(denominator);
            }
            return s;
        }

        public Fraction add(Fraction f){
            Fraction fResult = new Fraction();
            fResult.denominator = lcm(denominator, f.denominator);
            fResult.numerator = numerator * fResult.denominator / denominator + f.numerator * fResult.denominator / f.denominator;
            fResult.Cancellation();
            return fResult;
        }

        public Fraction subtract(Fraction f){
            Fraction fResult = new Fraction();
            fResult.denominator = lcm(denominator, f.denominator);
            fResult.numerator = numerator * fResult.denominator / denominator - f.numerator * fResult.denominator / f.denominator;
            fResult.Cancellation();
            return fResult;
        }

        public Fraction multiply(Fraction f){
            Fraction fResult = new Fraction();
            fResult.numerator = numerator * f.numerator;
            fResult.denominator = denominator * f.denominator;
            fResult.Cancellation();
            return fResult;
        }

        public Fraction divide(Fraction f){
            Fraction fResult = new Fraction();
            fResult.numerator = numerator * f.denominator;
            fResult.denominator = denominator * f.numerator;
            fResult.Cancellation();
            return fResult;
        }

        @Override
        public int compareTo(Fraction f){
            long g = gcd(denominator, f.denominator);
            long res = numerator * (f.denominator / g) - f.numerator * (denominator / g);
            if (res < 0){
                return -1;
            }
            if (res > 0){
                return 1;
            }
            return 0;
        }

        public Fraction clone(){
            Fraction fResult = new Fraction(numerator, denominator);
            return fResult;
        }

        public Fraction floor(){
            Fraction fResult = this.clone();
            fResult.numerator = (fResult.numerator / fResult.denominator) * fResult.denominator;
            return fResult;
        }

        public Fraction ceil(){
            Fraction fResult = this.clone();
            fResult.numerator = (fResult.numerator/fResult.denominator + 1) * fResult.denominator;
            return fResult;
        }

        public Fraction binpow(int n){
            if (n==0) return FRACTION_ONE;
            if ((n&1)==0){
                Fraction f=this.binpow(n/2);
                return f.multiply(f);
            }else return binpow(n-1).multiply(this);
        }
    }

    static public class FenwickTree_1{  //One-dimensional array

        int n;
        long[] t;

        public FenwickTree_1(int n){
            this.n = n;
            t = new long[n];
        }

        public long sum(int xl, int xr){
            return sum(xr) - sum(xl);
        }

        public long sum(int x){
            long result = 0;
            for (int i = x; i >= 0; i = (i & (i + 1)) - 1){
                result += t[i];
            }
            return result;
        }

        public void update(int x, long delta){
            for (int i = x; i < n; i = (i | (i + 1))){
                t[i] += delta;
            }
        }
    }

    static public class FenwickTree_2{  //Two-dimensional array

        int n, m;
        long[][] t;

        public FenwickTree_2(int n, int m){
            this.n = n;
            this.m = m;
            t = new long[n][m];
        }

        public long sum(int xl, int yl, int xr, int yr){
            return sum(xr, yr) - sum(xl - 1, yr) - sum(xr, yl - 1) + sum(xl - 1, yl - 1);
        }

        public long sum(int x, int y){
            long result = 0;
            for (int i = x; i >= 0; i = (i & (i + 1)) - 1){
                for (int j = y; j >= 0; j = (j & (j + 1)) - 1){
                    result+=t[i][j];
                }
            }
            return result;
        }

        public void update(int x, int y, long delta){
            for (int i = x; i < n; i = (i | (i + 1))){
                for (int j = y; j < m; j = (j | (j + 1))){
                    t[i][j] += delta;
                }
            }
        }
    }

    static public class FenwickTree_3{  //Three-dimensional array

        int n, m, l;
        long[][][] t;

        public FenwickTree_3(int n, int m, int l){
            this.n = n;
            this.m = m;
            this.l = l;
            t = new long[n][m][l];
        }

        public long sum(int xl, int yl, int zl, int xr, int yr, int zr){
            return sum(xr, yr, zr) - sum(xl - 1, yr, zr)
            + sum(xl - 1, yr, zl - 1) - sum(xr, yr, zl - 1)
            - sum(xr, yl - 1, zr) + sum(xl - 1, yl - 1, zr)
            - sum(xl - 1, yl - 1, zl - 1) + sum(xr, yl - 1, zl - 1);
        }

        public long sum(int x, int y, int z){
            long result = 0;
            for (int i = x; i >= 0; i = (i & (i + 1)) - 1){
                for (int j = y; j >= 0; j = (j & (j + 1)) - 1){
                    for (int k = z; k >= 0; k = (k & (k + 1)) - 1){
                        result += t[i][j][k];
                    }
                }
            }
            return result;
        }

        public void update(int x, int y, int z, long delta){
            for (int i = x; i < n; i = (i | (i + 1))){
                for (int j = y; j < n; j = (j | (j + 1))){
                    for (int k = z; k < n; k = (k | (k + 1))){
                        t[i][j][k] += delta;
                    }
                }
            }
        }
    }
}


/*
	Author	:	Imran Khan
	Language:	Java

*/

import java.io.*;
import java.util.*;
public class Main
{
	public class BasicInputOutput
	{

		private StringTokenizer strtoken;
		private BufferedReader bufferReader;
		private BufferedWriter bufferWriter;
		private String delim = " \t\n\r\f";
		BasicInputOutput()
		{
			delim = " \t\n\r\f";
			initialize();
		}
		BasicInputOutput( String s )
		{
			delim = s;
			initialize();
		}
		private void initialize()
		{
			bufferReader = new BufferedReader( new InputStreamReader( System.in ));
			bufferWriter = new BufferedWriter( new PrintWriter( System.out ));
			strtoken = null;
		}
		private void checkStringTokenizer()throws IOException
		{
			if ( strtoken == null || strtoken.hasMoreTokens() == false )
				strtoken = new StringTokenizer( bufferReader.readLine(), delim );
		}
		public int getNextInt()throws IOException
		{
			checkStringTokenizer();
			return Integer.parseInt( strtoken.nextToken());
		}

		public long getNextLong()throws IOException
		{
			checkStringTokenizer();
			return Long.parseLong( strtoken.nextToken());
		}

		public double getNextDouble()throws IOException
		{
			checkStringTokenizer();
			return Double.parseDouble( strtoken.nextToken());
		}

		public float getNextFloat()throws IOException
		{
			checkStringTokenizer();
			return Float.parseFloat( strtoken.nextToken());
		}

		public String getNextString()throws IOException
		{
			checkStringTokenizer();
			return strtoken.nextToken();
		}

		public String getNextLine()throws IOException
		{
			checkStringTokenizer();
			return bufferReader.readLine();
		}

		public void skipCurrentLine()throws IOException
		{
			checkStringTokenizer();
			strtoken = null;
		}
		public void write( String var )throws IOException
		{
			bufferWriter.write( var );
		}

		public < T > void write( char sep, T... var )throws IOException
		{
			if ( var.length == 0 )
				return ;
			bufferWriter.write( var[0].toString());
			for ( int i = 1; i < var.length; i++ )
				bufferWriter.write( sep + var[i].toString());
		}

		public void flush()throws IOException
		{
			bufferWriter.flush();
		}
	}

	public static void main(String[] args)
	{
		try
		{
			new Main().run();
		}
		catch (Exception ex)
		{
			ex.printStackTrace();
		}
	}
	private BasicInputOutput iohandler;
	private int n;
	private double[][] mat;
	private double[][] sum;
	private double[] dp;
	private int tolive;
	private void run()throws Exception
	{
		initialize();
		solve();
	}
	private void initialize() throws Exception
	{
		iohandler=new BasicInputOutput();
		n=iohandler.getNextInt();
		mat=new double[n][n];
		sum=new double[(1<<n)+10][n];
		dp=new double[1<<n];
		for(int i=0;i<n;i++) for(int j=0;j<n;j++)
		{
			mat[i][j]=iohandler.getNextDouble();
		}
	}
	private int bitCount(int mask)
	{
		int ret=0;
		while(mask>0) {
			ret++;
			mask&=(mask-1);
		}
		return ret;
	}
	private void solve() throws Exception
	{
		double[] ans=new double[n];
		int ub=1<<n;
		for(int i=1;i<ub;i++) {
			for(int j=0;j<n;j++) {
				sum[i][j]=0;
				for(int k=0;k<n;k++) if ((i&(1<<k))!=0) sum[i][j]+=mat[k][j];
				int cntbit=bitCount(i);
				if (cntbit>1)
				sum[i][j]/=((double)cntbit*(cntbit-1.))/2.;
			}
		}
		dp[ub-1]=1.;
		for(int mask=ub-1;mask>=1;mask--) {
			if (dp[mask]==0.) continue;
			for(int i=0;i<n;i++) {
				if ((mask&(1<<i))==0) continue;
				dp[mask-(1<<i)]+=sum[mask][i]*dp[mask];
			}
		}
		for(int i=0;i<n;i++)
		ans[i]=dp[1<<i];
		/*
		for(int i=0;i<n;i++)
		{
			for(int mask=1;mask<ub;mask++) {
				dp[mask]=0;
				if ((mask&(1<<i))==0) continue;
				if (bitCount(mask)==1)
				{
					dp[mask]=1.;
				} else
				for(int k=0;k<n;k++) {
					if ((mask&(1<<k))==0) continue;
					if (i==k) continue;
					dp[mask]+=sum[mask][k]*dp[mask-(1<<k)];
				}
			}
			ans[i]=dp[ub-1];
		}*/
		iohandler.write(ans[0]+"");
		for(int i=1;i<n;i++) iohandler.write(" "+ans[i]);
		iohandler.write("\n");
		iohandler.flush();
	}
}


import java.util.Arrays;
import java.util.Scanner;

public class Main {
    static double[] dp;
    static double[][] P;
    public static void main(String[] args) {
        Scanner r = new Scanner(System.in);

        int n = r.nextInt();

        double[][] g = new double[n][n];
        for(int i = 0; i < n; i++)
            for(int j = 0; j < n; j++)
                g[i][j] = r.nextDouble();

        dp = new double[1 << n];
        P = new double[1 << n][n];
        for(int mask = 0; mask < 1 << n; mask++){
            for(int d = 0; d < n; d++)if((mask & (1 << d)) == 0)
                for(int i = 0; i < n; i++)if((mask & (1 << i)) == 0){
                    if(i == d)continue;

                    P[mask][d] += g[i][d];
                }
        }

        for(int i = 0; i < n; i++){
            Arrays.fill(dp, -1);

            double res = go(i, 0, g, n, n);
            System.out.println(res);
        }
    }

    private static double go(int a, int v, double[][] g, int cnt, int n) {
        if(dp[v] != -1)return dp[v];

        if(cnt == 1){
            return 1;
        }else{
            double ret = 0;
            for(int d = 0; d < n; d++)if((v & (1 << d)) == 0 && d != a){
                double current =  P[v][d] * go(a, v | 1 << d, g, cnt-1, n);
                ret += current;
            }

            return dp[v] = ret/(cnt * (cnt-1) /2);
        }
    }
}


import java.util.Scanner;

public class A {

    public static int n;
    public static double[] masks;
    public static double[][] matrix;

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        n = scan.nextInt();

        matrix = new double[n][n];
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                matrix[i][j] = scan.nextDouble();

        masks = new double[1 << n];
        masks[(1 << n) - 1] = 1;
        for (int i = 0; (1 << i) < (1 << n); i++)
            fillDP(1 << i);

        for (int i = 0; (1 << i) < (1 << n); i++)
            System.out.printf("%.6f ", masks[1 << i]);

    }

    public static double fillDP(int mask) {
        int bitCount = Integer.bitCount(mask);

        if (masks[mask] != 0)
            return masks[mask];

        double matchProba = 2.0 / (((double) (bitCount)) * ((double) (bitCount + 1)));

        double totalProba = 0;
        for (int i = 0; i < n; i++) {
            int iPower = 1 << i;

            if ((mask & iPower) != iPower)
                continue;

            for (int j = 0; j < n; j++) {
                int jPower = 1 << j;

                if ((mask & jPower) == jPower || i == j)
                    continue;

                // still alive
                totalProba += (matchProba * matrix[i][j] * fillDP(mask | jPower));
            }
        }

        return masks[mask] = totalProba;

    }
}


/**
 * Created by IntelliJ IDEA.
 * User: Taras_Brzezinsky
 * Date: 8/14/11
 * Time: 9:53 PM
 * To change this template use File | Settings | File Templates.
 */

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.FileReader;
import java.util.StringTokenizer;
import java.io.IOException;
import java.util.Arrays;

public class Fish extends Thread {

    public Fish() {
        this.input = new BufferedReader(new InputStreamReader(System.in));
        this.output = new PrintWriter(System.out);
        this.setPriority(Thread.MAX_PRIORITY);
    }

    static int getOnes(int mask) {
        int result = 0;
        while (mask != 0) {
            mask &= mask - 1;
            ++result;
        }
        return result;
    }

    private void solve() throws Throwable {
        int n = nextInt();
        double[][] a = new double[n][n];
        double[] dp = new double[(1 << n)];
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                a[i][j] = nextDouble();
            }
        }
        int limit = (1 << n) - 1;
        //dp[mask] = probability of current subset (mask) to remain in the end
        dp[limit] = 1.0;
        for (int mask = limit; mask > 0; --mask) {
            int cardinality = getOnes(mask);
            int probability = cardinality * (cardinality - 1) / 2;
            for (int first = 0; first < n; ++first) {
                if ((mask & powers[first]) != 0) {
                    for (int second = first + 1; second < n; ++second) {
                        if ((mask & powers[second]) != 0) {
                            dp[mask - powers[first]] += dp[mask] * a[second][first] / probability;
                            dp[mask - powers[second]] += dp[mask] * a[first][second] / probability;
                        }

                    }
                }
            }
        }
        for (int i = 0; i < n; ++i) {
            output.printf("%.10f ", dp[powers[i]]);
        }
    }

    public void run() {
        try {
            solve();
        } catch (Throwable e) {
            System.err.println(e.getMessage());
            e.printStackTrace();
            System.exit(666);
        } finally {
            output.flush();
            output.close();
        }
    }

    public static void main(String[] args) {
        new Fish().start();
    }

    private String nextToken() throws IOException {
        while (tokens == null || !tokens.hasMoreTokens()) {
            tokens = new StringTokenizer(input.readLine());
        }
        return tokens.nextToken();
    }

    private int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    private double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    private long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    static int powers[] = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144};
    private BufferedReader input;
    private PrintWriter output;
    private StringTokenizer tokens = null;
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main16E {

    private FastScanner in;
    private PrintWriter out;

    public void solve() throws IOException {
        int n = in.nextInt();
        double[][] a = new double[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                a[i][j] = in.nextDouble();
            }
        }
        int k = 1 << n;
        double[] p = new double[k];
        int[][] b = new int[n + 1][];
        for (int i = 0; i <= n; i++) {
            b[i] = new int[comb(i, n)];
        }
        int[] bl = new int[n + 1];
        for(int i = 0; i < k; i++) {
            int c = c2(i);
            b[c][bl[c]] = i;
            bl[c]++;
        }
        p[k - 1] = 1;
        for (int i = n; i >= 2; i--) {
            for (int j = 0; j < b[i].length; j++) {
                int t = b[i][j];
                double pm = 1;
                pm /= (i * (i - 1) / 2);
                for (int x = 0; x < n; x++) {
                    for (int y = x + 1; y < n; y++) {
                        if ((t & (1 << x)) > 0 && (t & (1 << y)) > 0) {
                            p[t & ~(1 << x)] += p[t] * pm * a[y][x];
                            p[t & ~(1 << y)] += p[t] * pm * a[x][y];
                        }
                    }
                }
            }
        }
        for (int i = 0; i < n; i++) {
            out.print(p[1 << i] + " ");
        }
    }

    int comb(int n, int m) {
        int res = 1;
        for (int i = 1; i <= n; i++) {
            res = res * (m - i + 1);
            res /= i;
        }
        return res;
    }

    int c2(int k) {
        int res = 0;
        while (k > 0) {
            if (k % 2 == 1) {
                res ++;
            }
            k /= 2;
        }
        return res;
    }

    public void run() {
        try {
            in = new FastScanner(System.in);
            out = new PrintWriter(System.out);
            solve();
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    class FastScanner {

        BufferedReader br;
        StringTokenizer st;

        FastScanner(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }
    }

    public static void main(String[] arg) {
        new Main16E().run();
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;

public class ProblemE {

	static final int INF = 1000000;

	public static void main(String[] args) throws IOException {
		BufferedReader s = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(System.out);

		int n = Integer.valueOf(s.readLine());
		double[][] prob = new double[n][n];
		double[] dp = new double[1<<n];
		for (int i = 0 ; i < n ; i++) {
			String[] line = s.readLine().split(" ");
			for (int j = 0 ; j < n ; j++) {
				prob[i][j] = Double.valueOf(line[j]);
			}
		}

		dp[(1<<n)-1] = 1.0d;
		for (int p = (1<<n)-1 ; p >= 1 ; p--) {
			if (dp[p] > 0.0d) {
				int left = Integer.bitCount(p);
				if (left == 1) {
					continue;
				}
				double baseProb = 1.0d / (left * (left - 1) / 2);
				for (int i = 0 ; i < n ; i++) {
					if ((p & (1<<i)) == 0) {
						continue;
					}
					for (int j = i+1 ; j < n ; j++) {
						if ((p & (1<<j)) == 0) {
							continue;
						}
						dp[p-(1<<i)] += dp[p] * baseProb * prob[j][i];
						dp[p-(1<<j)] += dp[p] * baseProb * prob[i][j];
					}
				}
			}
		}

		StringBuffer b = new StringBuffer();
		for (int i = 0 ; i < n ; i++) {
			b.append(" ").append(dp[1<<i]);
		}
		out.println(b.substring(1));
		out.flush();
	}

	public static void debug(Object... os){
		System.err.println(Arrays.deepToString(os));
	}
}


import java.io.InputStreamReader;
import java.io.IOException;
import java.util.InputMismatchException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.Writer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Niyaz Nigmatullin
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		FastScanner in = new FastScanner(inputStream);
		FastPrinter out = new FastPrinter(outputStream);
		Fish solver = new Fish();
		solver.solve(1, in, out);
		out.close();
	}
}

class Fish {
    public void solve(int testNumber, FastScanner in, FastPrinter out) {
        int n = in.nextInt();
        double[][] p = new double[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                p[i][j] = in.nextDouble();
            }
        }
        double[] dp = new double[1 << n];
        dp[(1 << n) - 1] = 1;
        for (int mask = (1 << n) - 1; mask >= 0; mask--) {
            int countPairs = Integer.bitCount(mask);
            countPairs = countPairs * (countPairs - 1) / 2;
            for (int i = 0; i < n; i++) {
                if (((mask >> i) & 1) == 0) {
                    continue;
                }
                for (int j = i + 1; j < n; j++) {
                    if (((mask >> j) & 1) == 0) {
                        continue;
                    }
                    dp[mask ^ (1 << j)] += dp[mask] * p[i][j] / countPairs;
                    dp[mask ^ (1 << i)] += dp[mask] * p[j][i] / countPairs;
                }
            }
        }
        for (int i = 0; i < n; i++) {
            out.print(dp[1 << i] + " ");
        }
    }
}

class FastScanner extends BufferedReader {

    boolean isEOF;

    public FastScanner(InputStream is) {
        super(new InputStreamReader(is));
    }

    public int read() {
        try {
            int ret = super.read();
            if (isEOF && ret < 0) {
                throw new InputMismatchException();
            }
            isEOF = ret == -1;
            return ret;
        } catch (IOException e) {
            throw new InputMismatchException();
        }
    }

    public String next() {
        StringBuilder sb = new StringBuilder();
        int c = read();
        while (isWhiteSpace(c)) {
            c = read();
        }
        while (!isWhiteSpace(c)) {
            sb.appendCodePoint(c);
            c = read();
        }
        return sb.toString();
    }

    static boolean isWhiteSpace(int c) {
        return c >= -1 && c <= 32;
    }

    public int nextInt() {
        int c = read();
        while (isWhiteSpace(c)) {
            c = read();
        }
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int ret = 0;
        while (!isWhiteSpace(c)) {
            if (c < '0' || c > '9') {
                throw new NumberFormatException("digit expected " + (char) c
                        + " found");
            }
            ret = ret * 10 + c - '0';
            c = read();
        }
        return ret * sgn;
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }

    }

class FastPrinter extends PrintWriter {

    public FastPrinter(OutputStream out) {
        super(out);
    }

    public FastPrinter(Writer out) {
        super(out);
    }

}


import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.Locale;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.AbstractList;
import java.io.Writer;
import java.util.Collection;
import java.util.List;
import java.io.IOException;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.ArrayList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Jacob Jiang
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskE solver = new TaskE();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskE {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
        int n = in.nextInt();
        double[][] probability = in.next2DDoubleArray(n, n);
        double[] dp = new double[1 << n];
        dp[dp.length - 1] = 1;
        for (int mask = (1 << n) - 1; mask >= 0; mask--) {
            int count = Integer.bitCount(mask);
            if (count <= 1) continue;
            double multi = 1. / calc(count);
            for (int i = 0; i < n; i++) {
                if (NumberUtils.checkBit(mask, i)) {
                    for (int j = i + 1; j < n; j++) {
                        if (NumberUtils.checkBit(mask, j)) {
                            // i eat j
                            dp[mask - (1 << j)] += multi * probability[i][j] * dp[mask];
                            // j eat i
                            dp[mask - (1 << i)] += multi * probability[j][i] * dp[mask];
                        }
                    }
                }
            }
        }
        double[] answer = new double[n];
        for (int i = 0; i < n; i++) {
            answer[i] = dp[1 << i];
        }
        out.printLine(ArrayUtils.asList(answer).toArray());
    }

    private static int calc(int x) {
        return x * (x - 1) / 2;
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int nextInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c & 15;
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public static boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public double nextDouble() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        double res = 0;
        while (!isSpaceChar(c) && c != '.') {
            if (c == 'e' || c == 'E')
                return res * Math.pow(10, nextInt());
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        }
        if (c == '.') {
            c = read();
            double m = 1;
            while (!isSpaceChar(c)) {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                m /= 10;
                res += (c - '0') * m;
                c = read();
            }
        }
        return res * sgn;
    }

    public double[] nextDoubleArray(int count) {
        double[] result = new double[count];
        for (int i = 0; i < count; i++) {
            result[i] = nextDouble();
        }
        return result;
    }

    public double[][] next2DDoubleArray(int n, int m) {
        double[][] result = new double[n][];
        for (int i = 0; i < n; i++) {
            result[i] = nextDoubleArray(m);
        }
        return result;
    }

    }

class OutputWriter {
    PrintWriter writer;

    public OutputWriter(OutputStream stream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(stream)));
    }

    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void print(Object obj) {
        writer.print(obj);
    }

    public void println() {
        writer.println();
    }

    public void print(char c) {
        writer.print(c);
    }

    public void close() {
        writer.close();
    }

    public void printItems(Object... items) {
        for (int i = 0; i < items.length; i++) {
            if (i != 0) {
                print(' ');
            }
            print(items[i]);
        }
    }

    public void printLine(Object... items) {
        printItems(items);
        println();
    }

}

class NumberUtils {

    public static boolean checkBit(int mask, int bit) {
        return (mask & (1 << bit)) != 0;
    }

    }

class ArrayUtils {

    private ArrayUtils() {
    }

    public static List<Double> asList(double[] array) {
        return new DoubleList(array);
    }

    private static class DoubleList extends AbstractList<Double> {
        double[] array;

        private DoubleList(double[] array) {
            this.array = array;
        }

        public Double set(int index, Double element) {
            double result = array[index];
            array[index] = element;
            return result;
        }

        public Double get(int index) {
            return array[index];
        }

        public int size() {
            return array.length;
        }
    }

    }


import java.util.*;
import java.io.*;

public class Fish
{
    public static void main(String[] args) throws Exception { new Fish(); }

    public Fish() throws Exception
    {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        double[][] P = new double[N][N];
        for(int i = 0; i < N; i++)
            for(int j = 0; j < N; j++)
                P[i][j] = sc.nextDouble();

        double[] best = new double[1 << N];
        best[(1 << N)-1] = 1;
        for(int mask = (1 << N)-1; mask > 0; mask--)
        {
            int C = Integer.bitCount(mask);
            if(C == 1) continue;
            for(int i = 0; i < N; i++) if (on(mask, i))
                for(int j = i+1; j < N; j++) if(on(mask, j))
                {
                    int nmask = mask & ~(1 << j);
                    best[nmask] += P[i][j] * best[mask] * 2.0 / (C*(C-1.0));
                    nmask = mask & ~(1 << i);

                    best[nmask] += P[j][i] * best[mask] * 2.0/ (C*(C-1.0));
                }
        }

        for(int i = 0; i < N; i++)
            System.out.printf("%.7f ", best[1 << i] + 1e-9);
        System.out.println();
    }

    boolean on(int mask, int pos) { return (mask & (1 << pos)) > 0; }

}


import java.util.Arrays;
import java.util.Scanner;

public class E {
    static double[] dp;
    static int[] oneCount;
    static int end;
    static int n;
    static double[][] prob;
    public static double solve(int mask) {
        if(mask==end) return 1;
        int oneC=0,zeroC=0;
        for(int i=0;i<n;i++) {
            if((mask|(1<<i))==mask) oneC++;
            else zeroC++;
        }
        double res=0;
        for(int i=0;i<n;i++) {
            if((mask|(1<<i))!=mask) continue;
            for(int j=0;j<n;j++) {
                //
                if((mask|(1<<j))==mask) continue;
                //System.out.println(i+" "+j+" "+prob[i][j]+" "+Integer.toBinaryString(mask)+" "+oneC+" "+zeroC);
                res+=(1.0/((oneC*(oneC+1))/2))*prob[i][j]*solve(mask|(1<<j));
            }
        }
        return dp[mask]=res;
    }
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        prob=new double[n][n];
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                prob[i][j]=sc.nextDouble();
        dp=new double[1<<n];
        oneCount=new int[1<<n];
        int c;
        for(int i=0;i<dp.length;i++) {
            c=0;
            for(int j=0;j<n;j++) {
                if((i|(1<<j))==i) c++;
            }
            oneCount[i]=c;
        }
        end=(1<<n)-1;
        double res,rad;
        int count;
        for(int k=end;k>0;k--) {
            if(k==end) dp[k]=1;
            else {
                res=0;
                count=oneCount[k];
                count=count*(count+1);
                count>>=1;
                rad=1.0/count;
                //System.out.println(rad+" "+count);
                for(int i=0;i<n;i++) {
                    if((k|(1<<i))!=k) continue;
                    for(int j=0;j<n;j++) {
                        //
                        if((k|(1<<j))==k) continue;
                        //System.out.println(i+" "+j+" "+prob[i][j]+" "+Integer.toBinaryString(mask)+" "+oneC+" "+zeroC);
                        res+=rad*prob[i][j]*dp[k|(1<<j)];
                    }
                }
                dp[k]=res;
            }
        }
        //Arrays.fill(dp, -1);
        for(int i=0;i<n;i++)
            System.out.print(dp[1<<i]+" ");
            //System.out.print(solve(1<<i)+" ");
//      for(int i=0;i<18;i++){
//          for(int k=0;k<18;k++)
//              System.out.print(Math.random()+" ");
//          System.out.println();
//      }
    }
}


import java.io.*;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.fill;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.sort;

public class Main {
	public static void main(String[] args) throws IOException {
		try {
			if (new File("input.txt").exists()) {
				System.setIn(new FileInputStream("input.txt"));
			}
		} catch (SecurityException e) {
		}

		new Main().run();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		int N = nextInt();
		double[][] a = new double [N][N];

		for (int i = 0; i < N; i++)
			for (int j = 0; j < N; j++)
				a[i][j] = nextDouble();

		int NN = 1 << N;

		double[] dp = new double [NN];
		dp[NN - 1] = 1.0;

		for (int mask = NN - 1; mask > 0; mask--) {
			int b = Integer.bitCount(mask);
			if (b <= 1)
				continue;

			double k = 2.0 / (b * (b - 1));

			for (int i = 0; i < N; i++) {
				if ((mask & (1 << i)) == 0)
					continue;

				for (int j = i + 1; j < N; j++) {
					if ((mask & (1 << j)) == 0)
						continue;

					double p = a[i][j];
					dp[mask & (~(1 << j))] += k * p * dp[mask];
					dp[mask & (~(1 << i))] += k * (1.0 - p) * dp[mask];
				}
			}
		}

		out.printf(Locale.US, "%.8f", dp[1]);

		for (int i = 1, ind = 2; i < N; ind <<= 1, i++)
			out.printf(Locale.US, " %.8f", dp[ind]);
		out.println();
		out.close();
	}

	String nextToken() throws IOException {
		while (!st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}

		return st.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}

	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}


import java.io.*;
import java.util.*;

public class Main {
	static Scanner in;
	static PrintWriter out;
//	static StreamTokenizer in; static int next() throws Exception {in.nextToken(); return (int) in.nval;}

	public static void main(String[] args) throws Exception {
		in = new Scanner(System.in);
		out = new PrintWriter(System.out);
//		in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

		int n = in.nextInt();

		double[][] p = new double[n][n];
		for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) p[i][j] = in.nextDouble();

		double[] q = new double[1 << n];
		q[(1 << n) - 1] = 1;
		for (int mask = (1 << n) - 1; mask > 0; mask--) {
			int count = 0;

			for (int t = 0; t < n; t++) if (((1 << t) & mask) != 0) count++;
			if (count <= 1) continue;
			count = count*(count - 1)/2;

			for (int t = 0; t < n; t++) if (((1 << t) & mask) != 0)
				for (int s = 0; s < t; s++) if (((1 << s) & mask) != 0) {
					q[mask - (1 << t)] += q[mask] / count * p[s][t];
					q[mask - (1 << s)] += q[mask] / count * p[t][s];
				}
		}

		for (int i = 0; i < n; i++) out.print(q[1 << i] + " ");

		out.close();
	}
}


import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.util.*;

import static java.lang.Math.*;

public class BetaRound16_E implements Runnable {

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok = new StringTokenizer("");

	public static void main(String[] args) {
		new Thread(null, new BetaRound16_E(), "", 256 * (1L << 20)).start();
	}

	public void run() {
		try {
			long t1 = System.currentTimeMillis();
			if (System.getProperty("ONLINE_JUDGE") != null) {
				in = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			} else {
				in = new BufferedReader(new FileReader("input.txt"));
				out = new PrintWriter("output.txt");
			}
			Locale.setDefault(Locale.US);
			solve();
			in.close();
			out.close();
			long t2 = System.currentTimeMillis();
			System.err.println("Time = " + (t2 - t1));
		} catch (Throwable t) {
			t.printStackTrace(System.err);
			System.exit(-1);
		}
	}

	String readString() throws IOException {
		while (!tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	int readInt() throws IOException {
		return Integer.parseInt(readString());
	}

	long readLong() throws IOException {
		return Long.parseLong(readString());
	}

	double readDouble() throws IOException {
		return Double.parseDouble(readString());
	}

	// solution

	double[] p;
	int n;
	double[][] a;

	void solve() throws IOException {
		n = readInt();
		a = new double[n][n];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				a[i][j] = readDouble();
			}
		}
		p = new double[1 << n];
		Arrays.fill(p, -1);
		p[(1 << n) - 1] = 1;
		for (int i = 0; i < n; i++) {
			out.printf("%.12f ", p(1 << i));
		}
	}

	double p(int mask) {
		if (p[mask] != -1) return p[mask];
		double ans = 0;
		for (int eaten = 0; eaten < n; eaten++) {
			int prev = mask | (1 << eaten);
			if (prev != mask) {
				for (int eats = 0; eats < n; eats++) {
					if ((mask & (1 << eats)) != 0) {
						ans += a[eats][eaten] * p(prev);
					}
				}
			}
		}
		int bc = Integer.bitCount(mask);
		int norm = bc * (bc + 1) / 2;
		return p[mask] = ans / norm;
	}

}


// by agus.mw
import java.util.*;
import java.io.*;

public class Main{
  public static void main(String[] args) throws Exception {
    new Main().doWork();
  }
  void doWork() throws Exception{
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));

    int ncase = Integer.valueOf(reader.readLine());
    double[][] p = new double[ncase][];
    for(int icase=0;icase<ncase;icase++){
      p[icase] = toDoubleArray(reader.readLine());
    }
    double[] prob = new double[1<<ncase];
    prob[0] = 1;
    for(int x=0;x<(1<<ncase);x++){
      double cp = prob[x];
      int count = 0;
      for(int i=0;i<ncase;i++){
        if((x&(1<<i))!=0) continue;
        count ++;
      }
      if(count == 1) continue;
      double np = cp*2.0/(count)/(count-1);
      for(int i=0;i<ncase;i++){
        if((x&(1<<i))!=0) continue;
        for(int j=i+1;j<ncase;j++){
          if((x&(1<<j))!=0) continue;
          prob[x^(1<<j)] += np*p[i][j];
          prob[x^(1<<i)] += np*p[j][i];
        }
      }
    }
    String out = "";
    for(int i=0;i<ncase;i++){
      if(i>0) out += " ";
      int index = ((1<<ncase)-1)^(1<<i);
      out += String.format("%.6f",prob[index]);
    }
    out += "\r\n";
    writer.write(out,0,out.length());
    writer.flush();
    writer.close();
    reader.close();
  }
  String process(){
    return "1";
  }
  double[] toDoubleArray(String line){
    String[] p = line.split("[ ]+");
    double[] out = new double[p.length];
    for(int i=0;i<p.length;i++) out[i] = Double.valueOf(p[i]);
    return out;
  }
}


import java.io.*;
import java.util.*;
import static java.util.Arrays.*;

public class E implements Runnable
{
    public static void main(String[] args) throws IOException
    {
        new Thread(null, new E(), "", 1 << 20).start();
    }

    BufferedReader input;
    PrintWriter out;
    String file = "input";

    public void run()
    {
        try
        {
            //input = new BufferedReader(new FileReader(file + ".in"));
            input = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(new BufferedOutputStream(System.out));
            solve();

            out.close();
        }
        catch(Exception e)
        {
            e.printStackTrace();
            System.exit(1);
        }
    }

    void solve() throws IOException
    {
        int n = Integer.parseInt(input.readLine());
        double[][] p = new double[n][n];
        for(int i = 0; i < n; i++)
        {
            StringTokenizer st = new StringTokenizer(input.readLine());
            for(int j = 0; j < n; j++)
            {
                p[i][j] = Double.parseDouble(st.nextToken());
            }
        }
        double[] dp = new double[1 << n];
        int mask = (1 << n) - 1;
        dp[mask] = 1;
        for(int w = mask; w > 0; w--)
        {
            int count = 0;
            for(int i = 0; i < n; i++)
                for(int j = i + 1; j < n; j++)
                    if((w >> i & 1) != 0 && (w >> j & 1) != 0) count++;

            if(count == 0) continue;
            for(int i = 0; i < n; i++)
                for(int j = i + 1; j < n; j++)
                    if((w >> i & 1) != 0 && (w >> j & 1) != 0)
                    {
                        dp[w ^ (1 << i)] += 1.0 / count * p[j][i] * dp[w];
                        dp[w ^ (1 << j)] += 1.0 / count * p[i][j] * dp[w];
                    }
        }
        for(int i = 0; i < n; i++)
            System.out.print(dp[1 << i] + " ");

    }
}


import java.io.*;
import java.util.*;
public class f {
	static int n;
	static double[][] g;
public static void main(String[] args) throws IOException {
	input.init(System.in);
	PrintWriter out = new PrintWriter(System.out);
	n = input.nextInt();
	g = new double[n][n];
	for(int i = 0; i<n; i++)
		for(int j = 0; j<n; j++)
			g[i][j] = input.nextDouble();
	for(int i = 0; i<n; i++)
		for(int j = 0; j<n; j++)
			g[j][i] = 1 - g[i][j];
	for(int i = 0; i<n; i++)
	{
		double[] dp = new double[1<<n];
		for(int mask = 0; mask < (1<<n); mask++)
		{
			if((mask & (1<<i)) == 0)
			{
				dp[mask] = 0;
				continue;
			}
			if(mask == (1<<i))
			{
				dp[mask] = 1;
				continue;
			}
			int count = Integer.bitCount(mask);
			double prob = 1.0 / (count * (count-1)/2);
			for(int a = 0; a<n; a++)
			{
				if((mask & (1<<a)) == 0) continue;
				for(int b = a+1; b<n; b++)
				{
					if((mask & (1<<b)) == 0) continue;
					double p = g[a][b] * dp[mask ^ (1<<b)] + g[b][a] * dp[mask ^ (1<<a)];
					dp[mask] += p;
				}
			}
			dp[mask] *= prob;
		}
		out.print(dp[(1<<n)-1]+" ");
	}
	out.close();
}
public static class input {
	static BufferedReader reader;
	static StringTokenizer tokenizer;

	static void init(InputStream input) {
		reader = new BufferedReader(new InputStreamReader(input));
		tokenizer = new StringTokenizer("");
	}

	static String next() throws IOException {
		while (!tokenizer.hasMoreTokens())
			tokenizer = new StringTokenizer(reader.readLine());
		return tokenizer.nextToken();
	}

	static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	static double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}

	static long nextLong() throws IOException {
		return Long.parseLong(next());
	}
}
}


/**
 * Created by IntelliJ IDEA.
 * User: aircube
 * Date: 11.01.11
 * Time: 4:14
 * To change this template use File | Settings | File Templates.
 */

import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.concurrent.Exchanger;

public class Template {
    BufferedReader br;
    PrintWriter out;
    StringTokenizer st;

    public static void main(String[] args) throws IOException {
        new Template().run();
    }

    void run() throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        st = null;
        out = new PrintWriter(System.out);
        solve();
        br.close();
        out.close();
    }
    double dm[];
    double a[][];
    boolean fil[];
    int p[];
    int n;
    // x & (x - 1)
    // 10
    //
    void solve() throws  IOException {
        n = nextInt();
        a = new double[n][n];
        for(int i = 0; i < n; ++i)
            for (int j = 0; j < n; ++j) {
                a[i][j] = nextDouble();
            }
        dm = new double[1 << n];
        fil = new boolean[1 << n];
        for(int i = 0; i < n; ++i) {
            out.print(brute((1 << i)) + " ");
        }
    }

    private double brute(int mask) {
        if (Integer.bitCount(mask) == n) return 1;
        if (fil[mask]) return dm[mask];
        int c = Integer.bitCount(mask);
        double res = 0;
        double p = 2.0 / (double) (c + 1) / (double)(c ) ;
        for(int i = 0; i < n; ++i) {
            for(int j = 0; j < n; ++j) {
                if ((mask & (1 << i)) == 0 && (mask & (1 << j)) > 0) {
                    res += a[j][i] * brute(mask ^ (1 << i));
                }
            }
        }
        res *= p;
        dm[mask] = res;
        fil[mask] = true;
        return dm[mask];
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    String nextToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(br.readLine());
        }
        return st.nextToken();
    }
}


import java.io.*;
import java.text.DecimalFormat;

public class ProblemD {

    private double survive(int round, int set) {
        if (sur[round][set] >= 0)
            return sur[round][set];
        double res = 0.0;
        int count = 0;
        for(int i=0;i<n;i++) {

            if ((set & (1 << i)) > 0) {
                double res2 = 0.0;
                for(int j=0;j<n;j++)
                    if ((set & (1 << j)) == 0) {
                        res2 += survive(round - 1, set + (1 << j)) * a[i][j];
                        count++;
                    }
                res += res2;
            }

        }
        count = (n-round+1) * (n - round) / 2;
        sur[round][set] = res / count;
        return sur[round][set];
    }

    int n;
    double[][] a, sur;

    public void solve() {
        boolean oj = true;

        try {
            Reader reader = oj ? new InputStreamReader(System.in) : new FileReader("inputD.txt");
            Writer writer = oj ? new OutputStreamWriter(System.out) : new FileWriter("outputD.txt");
            BufferedReader br = new BufferedReader(reader);
            PrintWriter out = new PrintWriter(writer);

            MyTokenizer tok = new MyTokenizer(br.readLine());
            n = (int)tok.getNum();
            a = new double[n][n];

            int all = (1 << n) - 1;

            sur = new double[n][all + 1];
            for(int i=0;i<n;i++) {
                tok = new MyTokenizer(br.readLine());
                for(int j=0;j<n;j++) {
                    a[i][j] = tok.getNum();
                }
                for(int j=0;j<=all;j++)
                    sur[i][j] = -1;
            }

            DecimalFormat format = new DecimalFormat("0.000000");

            sur[0][all] = 1;
            double[] res = new double[n];
            for(int i=0;i<n;i++) {
                res[i] = survive(n - 1, 1 << i);
                String sres = format.format(res[i]).replace(',','.');
                out.printf("%s ", sres);
            }

            br.close();
            out.close();
            reader.close();
            writer.close();
        }
        catch (Exception ex) {
            ex.printStackTrace();
        }
        finally {
        }
    }

    public static void main(String[] args) {
        ProblemD f = new ProblemD();
        f.solve();
    }

    private class MyTokenizer {
        private String s;
        private int cur;

        public MyTokenizer(String s) {
            this.s = s;
            cur = 0;
        }

        public void skip() {
            while (cur < s.length() && (s.charAt(cur) == ' ' || s.charAt(cur) == '\n')) {
                cur++;
            }
        }

        public double getNum() {
            skip();
            String snum = "";
            while (cur < s.length() && (s.charAt(cur) >= '0' && s.charAt(cur) <= '9' || s.charAt(cur) == '.')) {
                snum += s.charAt(cur);
                cur++;
            }
            return Double.valueOf(snum);
        }

        public String getString() {
            skip();
            String s2 = "";
            while (cur < s.length() && (s.charAt(cur) >= 'a' && s.charAt(cur) <= 'z')) {
                s2 += s.charAt(cur);
                cur++;
            }
            return s2;
        }

        public char getCurrentChar() throws Exception {
            if (cur < s.length())
                return s.charAt(cur);
            else
                throw new Exception("Current character out of string length");
        }

        public void moveNextChar() {
            if (cur < s.length())
                cur++;
        }

        public boolean isFinished() {
            return cur >= s.length();
        }
    }
}


import java.util.*;
import java.io.*;

public class Main{

  public void run(){
    Locale.setDefault(Locale.US);
    Scanner in = new Scanner(System.in);
    int n = in.nextInt();
    double a[][] = new double[n][n];
    for(int i=0;i<n;i++) for(int j=0;j<n;j++) a[i][j] = in.nextDouble();

    double f[] = new double[1<<n];
    f[(1<<n)-1] = 1;

    for(int mask = (1<<n)-1;mask > 0;mask--){
      int k = Integer.bitCount(mask);
      if (k == 1) continue;

      for(int i=0;i<n;i++){
        if ((mask & (1 << i)) > 0){
          for(int j=0;j<n;j++){
            if ((mask & (1 << j)) > 0){
              f[mask&(~(1<<j))]+=f[mask]*a[i][j]/(k*(k-1)/2);
            }
          }
        }
      }
    }
    for(int i=0;i<n;i++)
      System.out.print(f[1<<i]+" ");
  }

  public static void main(String args[]){
    new Main().run();
  }
}