n fish, numbered from 1 to n, live in a lake. Every day right one pair of fish meet, and the probability of each other pair meeting is the same. If two fish with indexes i and j meet, the first will eat up the second with the probability aij, and the second will eat up the first with the probability aji = 1 - aij. The described process goes on until there are at least two fish in the lake. For each fish find out the probability that it will survive to be the last in the lake.

Input

The first line contains integer n (1 ≤ n ≤ 18) — the amount of fish in the lake. Then there follow n lines with n real numbers each — matrix a. aij (0 ≤ aij ≤ 1) — the probability that fish with index i eats up fish with index j. It's guaranteed that the main diagonal contains zeros only, and for other elements the following is true: aij = 1 - aji. All real numbers are given with not more than 6 characters after the decimal point.

Output

Output n space-separated real numbers accurate to not less than 6 decimal places. Number with index i should be equal to the probability that fish with index i will survive to be the last in the lake.

Examples

Input

2
0 0.5
0.5 0


Output

0.500000 0.500000 

Input

5
0 1 1 1 1
0 0 0.5 0.5 0.5
0 0.5 0 0.5 0.5
0 0.5 0.5 0 0.5
0 0.5 0.5 0.5 0


Output

1.000000 0.000000 0.000000 0.000000 0.000000 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

//import hacker51.FastReader;

public class Main {
	static class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
        public FastReader() 
        { 
            br = new BufferedReader(new
                     InputStreamReader(System.in)); 
        } 
        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                try
                { 
                    st = new StringTokenizer(br.readLine()); 
                } 
                catch (IOException  e) 
                { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 
        int nextInt() 
        { 
            return Integer.parseInt(next()); 
        } 
        long nextLong() 
        { 
            return Long.parseLong(next()); 
        } 
        double nextDouble() 
        { 
            return Double.parseDouble(next()); 
        } 
        String nextLine() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        }
    }
	
	public static void main(String[] args) {
		OutputStream outputStream =System.out;
	    PrintWriter out =new PrintWriter(outputStream);
	FastReader s=new FastReader();
	int n=s.nextInt();
	double[][] prob=new double[n][n];
	for(int i=0;i<n;i++) {
		for(int j=0;j<n;j++) {
			prob[i][j]=s.nextDouble();
		}
	}
	for(int i=0;i<(1<<n)-1;i++) {
		dp5[i]=-0.9;
	}
	for(int i=0;i<n;i++) {
	double v=solve(1<<i,n,prob);
	out.print(String.format("%.6f",v)+" ");
	}
		out.close();

	}
	static double[] dp5=new double[1<<18];
	static double give(int mask,int i,double[][] prob,int n) {
		double ans=0;
		int c=Integer.bitCount(mask);
		long d=(c*(c-1))/2;
		for(int j=0;j<n;j++) {
			if(j!=i && ((1<<j)&mask)!=0) {
				ans+=prob[j][i];
			}
		}
		ans/=d;
		return ans;
	}
	static double solve(int mask,int n,double[][] prob) {
		if(mask==((1<<n)-1)) {
			return 1;
		}
		if(dp5[mask]>-0.9) {
			return dp5[mask];
		}
		double ans=0;
		for(int i=0;i<n;i++) {
			if((mask&(1<<i))==0) {
				int prev=(mask^(1<<i));
				double u=solve(mask^(1<<i),n,prob);
				double cal=u*give(prev,i,prob,n);
				ans+=cal;
			}
		}	
		return dp5[mask]=ans;
	
	}
	
	
	
	
	
	
	
	
	
	
	static boolean good(long[] a,long time,int n,long t) {
		long sum=0;
		for(int i=0;i<n;i++) {
			sum+=time/a[i];
		}
		return sum>=t;
	}
	static int[] t=new int[200001];
	static class pair5 implements Comparable<pair5>{
		private int a;
		private int i;
//		private int j;
		pair5(int a,int i) {
			this.a=a;
			this.i=i;
//			this.j=j;
		}
		public int compareTo(pair5 o) {
	         if(o.a>this.a) {
	        	 return -1;
	         }
	         if(o.a==this.a) {
	        	 return 0;
	         }
	         return 1;
		}
	}
	static class pair4 implements Comparable<pair4>{
	private int a;
	private int b;
//	private int id;
	pair4(int a,int b) {
		this.a=a;
		this.b=b;
//		this.id=id;
	}
		public int compareTo(pair4 p) {
			if(p.b<this.b) {
				return 1;
			}else if(p.b==this.b) {
				return p.a<=this.a?1:-1;
			}else {
				return -1;
			}
		}
		
	}
	static class type implements Comparable<type>{
		private int left;
		private int right;
		private int i;
		type(int left,int right,int i){
			this.left=left;
			this.right=right;
			this.i=i;
		}
		
		@Override
		public int compareTo(type r1) {
			// TODO Auto-generated method stub
			if (r1.left < this.left)
	            return 1;
	      if (r1.left > this.left)
	            return -1;
	      return r1.right > this.right?1:-1;
			
		}
	}
	
	static long[][][] dp=new long[1001][1001][2];
	static int m=0;
	static long get(int n,int k,int d) {
		if(k==1) {
			dp[n][1][d]=1;
			return 1;
		}
		if(dp[n][k][d]!=-1) {
			return (dp[n][k][d])%mod;
		}
		long ans=2;
		if(d==1) {
			if(n>1) {
				ans+=((get(n-1,k-1,d^1)%mod)-1)%mod;
			}
			if(n<m) {
				ans+=((get(n+1,k,d)%mod)-1)%mod;
			}
		}else {
			if(n>1) {
				ans+=((get(n-1,k,d)%mod)-1)%mod;
			}
			if(n<m) {
				ans+=((get(n+1,k-1,d^1)%mod)-1)%mod;
			}
			
		}
		dp[n][k][d]=ans%mod;
		return ans%mod;
	}
	static long mod=1000000007;
	public static long GCD1(long a,long b) {
		if(b==(long)0) {
			return a;
		}
		return GCD(b , a%b);
	}
	static HashMap<Integer,Integer> um=new HashMap<>();
	
	 static class pair implements Comparable<pair> {
         private  long len;
         private long time;	
//         private  long beauty;
         public pair(long len, long time) {
             this.len = len;
             this.time = time;
         }

         @Override
         public int compareTo(pair item) {
             return Long.compare(this.time, item.time);
         }
     }
	 
//
// 
	public static int lower_bound(ArrayList<Long> a ,int n,long x) {
		int l=-1;
		int r=n;
		while(r>l+1) {
			int mid=(l+r)/2;
			if(a.get(mid)>x) {
				r=mid;
			}else {
				l=mid;
			}
		}
		return r;
				
	}
	public static int upper_bound(long[] a ,int n,long x) {
		int l=-1;
		int r=n;
		while(r>l+1) {
			int mid=(l+r)/2;
			if(a[mid]<=x) {
				l=mid;
			}else {
				r=mid;
			}
		}
		return l;
				
	}
//
	static class t1 implements Comparable<t1>{
		private int a;
		private int b;
		t1(int a,int b){
			this.a=a;
			this.b=b;
		}
		@Override
		public int compareTo(t1 p1) {
			// TODO Auto-generated method stub
			if (p1.a < this.a)
	            return 1;
	      if (p1.a > this.a)
	            return -1;
	      return p1.b > this.b?1:-1;
		}
	}
	static class pair2 implements Comparable<pair2>{
		private long a;
		private int b;
		pair2(long a,int b){
			this.a=a;
			this.b=b;
		}
		public int compareTo(pair2 p) {
			return Long.compare(this.a,p.a);
		}
	}
	public static int longest_Common_Substring_using_top_down(String str1,String str2,int n,int m) {
		int[][] dp=new int[n+1][m+1];
		int max=Integer.MIN_VALUE;
		for(int i=1;i<=n;i++) {
			for(int j=1;j<=m;j++) {
				if(str1.charAt(i-1)==str2.charAt(j-1)) {
					dp[i][j]=1+dp[i-1][j-1];
					max=Math.max(max, dp[i][j]);
				}else {
					dp[i][j]=0;//since substring are continuous
				}
			}
		}
		
		return max;
	}
	
	public static pair[] merge_sort(pair[] A, int start, int end) {
		if (end > start) {
			int mid = (end + start) / 2;
			pair[] v = merge_sort(A, start, mid);
			pair[] o = merge_sort(A, mid + 1, end);
			return (merge(v, o));
		} else {
			pair[] y = new pair[1];
			y[0] = A[start];
			return y;
		}
	}
	public static pair[] merge(pair a[], pair b[]) {
//		int count=0;
		pair[] temp = new pair[a.length + b.length];
		int m = a.length;
		int n = b.length;
		int i = 0;
		int j = 0;
		int c = 0;
		while (i < m && j < n) {
			if (a[i].time < b[j].time) {
				temp[c++] = a[i++];
			
			} else {
				temp[c++] = b[j++];
			}
		}
		while (i < m) {
			temp[c++] = a[i++];
		}
		while (j < n) {
			temp[c++] = b[j++];
		}
		return temp;
	}
	static boolean ok(long n) {
		long sum=0;
		while(n>0) {
			sum+=n%10;
			n/=10;
		}
		return (sum==10);
	}
	static long ok1(long n) {
		long sum=0;
		while(n>0) {
			sum+=n%10;
			n/=10;
		}
		return sum;
	}
	static long get1(long n) {
		long f=0;
//		long f2=9;
		while(n>0) {
			f=Math.max(f, n%10);
			n/=10;
		}
		return f;
	}
	static long get2(long n) {
		long f=9;
//		long f2=9;
		while(n>0) {
			f=Math.min(f, n%10);
			n/=10;
		}
		return f;
	}
	static long get(long n,long k,long count) {
		if(count==k) {
			return n;
		}else {
			long t1=get1(n);
			long t2=get2(n);
			long y=n+t1*t2;
			return get(y,k,count+1);
		}
	}
	
	
	public static int lower_bound(ArrayList<Integer> a ,int n,int x) {
		int l=-1;
		int r=n;
		while(r>l+1) {
			int mid=(l+r)/2;
			if(a.get(mid)<=x) {
				l=mid;
			}else {
				r=mid;
			}
		}
		return l;
				
	}
	public static long longest_Segment_sum_less_than_equal_to_S(long[] a,long sum,int n) {
		int l=0;
		long x=0;
		long res=0;
		for(int r=0;r<n;r++) {
			x+=a[r];
			while(x>sum) {
				x-=a[l];
			l++;
			}
			res=Math.max(r-l+1,res);
		}
		return res;
	}
	public static long shortest_Segment_sum_greater_than_equal_to_S(long[] a,long sum,int n) {
		int l=0;
		long x=0;
		long res=Integer.MAX_VALUE;
		for(int r=0;r<n;r++) {
			x+=a[r];
			while(x-a[l]>=sum) {
				x-=a[l];
				l++;
			}
			if(x>=sum) {
				res=Math.min(res, r-l+1);
			}
		}
		return res;
	}
	public static long total_Segment_sum_less_than_equal_to_S(long[] a,long sum,int n) {
	
		int l=0;
		long x=0;
		long res=0;
		for(int r=0;r<n;r++) {
			x+=a[r];
			while(x>sum) {
				x-=a[l];
				l++;
			}
			res+=((r-l+1));
		}
		return res;
	}
	public static long total_Segment_sum_greater_than_equal_to_S(long[] a,long sum,int n) {
		
		int l=0;
		int l1=-1;
		int r1=-1;
		long x=0;
		long res=0;
		for(int r=0;r<n;r++) {
			x+=a[r];
			while(x-a[l]>=sum) {
				x-=a[l];
				l++;
			}
			if(x>=sum && l!=l1 && r!=r1) {
				res+=(long)(l-l1)*(n-r);
				l1=l;
//				System.out.println(l+" "+l1+" "+r+" "+r1);
			}
			r1=r;
		}
		return res;
	}
	public static long total_Segment_unique_elements_less_than_equal_to_S(long[] a,long k,int n) {
		int l=0;
//		int r=0;
		int count=0;
		long res=0;
		int[] ct=new int[100001];
		for(int r=0;r<n;r++) {
			ct[(int) a[r]]++;
			if(ct[(int) a[r]]==1) {
				count++;
			}
				while(count>k) {
					ct[(int) a[l]]--;
					if(ct[(int) a[l]]==0) {
						count--;
					}
					l++;
				}
				res+=(r-l+1);
			
		}
		return res;
		
	}
	public static long segment_with_maximum_spread(long[] a,int n,long k)
	{
		int l=0;
		long count=0;
	for(int r=0;r<n;r++) {
		add(a[r]);
		while(!good(k)) {
			remove();
			l++;
		}
		count+=r-l+1;
//		System.out.println(r+" "+l);
	}
		return count;
	}
	
public static class Stack1{
	
	private  Stack<Long> st;
	private  Stack<Long> smin;
	private  Stack<Long> smax;
Stack1(){
	this.st=new Stack<>();
	this.smin=new Stack<>();
	this.smax=new Stack<>();
	this.smin.add(Long.MAX_VALUE);
	this.smax.add(Long.MIN_VALUE);
}	 
	
}
static Stack1 st1=new Stack1();
static Stack1 st2=new Stack1();
static void add(long d) {
	st2.st.add(d);
	st2.smin.add(Math.min(d, st2.smin.peek()));
	st2.smax.add(Math.max(st2.smax.peek(),d));
}
static void remove() {
	if(st1.st.isEmpty()) {
		while(!st2.st.isEmpty()) {
			st1.st.add(st2.st.pop());
			st2.smin.pop();
			st2.smax.pop();
			st1.smax.add(Math.max(st1.smax.peek(), st1.st.peek()));
			st1.smin.add(Math.min(st1.smin.peek(), st1.st.peek()));
		}}
		st1.st.pop();
		st1.smax.pop();
		st1.smin.pop();
	
}
static boolean good(long k) {
	long min=Math.min(st1.smin.peek(), st2.smin.peek());
	long max=Math.max(st1.smax.peek(), st2.smax.peek());
	return max-min<=k;
}



public static class Stack2{
	
	private  Stack<Long> st;
	private  Stack<Long> gcd;
Stack2(){
	this.st=new Stack<>();
	this.gcd=new Stack<>();
	gcd.add((long) 0);
}	 
	
}
static Stack2 st3=new Stack2();
static Stack2 st4=new Stack2();
static void add2(long d) {
	st4.st.add(d);
	st4.gcd.add(GCD(st4.gcd.peek(),d));
}
static void remove2() {
	if(st3.st.isEmpty()) {
		while(!st4.st.isEmpty()) {
			st3.st.add(st4.st.pop());
			st4.gcd.pop();
			st3.gcd.add(GCD(st3.gcd.peek(),st3.st.peek()));
			
		}}
		st3.st.pop();
		st3.gcd.pop();
	
}
static boolean good2() {
	if(st3.st.isEmpty()) {
		while(!st4.st.isEmpty()) {
			st3.st.add(st4.st.pop());
			st4.gcd.pop();
			st3.gcd.add(GCD(st3.gcd.peek(),st3.st.peek()));
			
		}}
	long d=st3.gcd.pop();
	long g=st3.gcd.peek();
	st3.gcd.add(d);
	return GCD(g,st4.gcd.peek())==1;
}


public static long GCD(long a,long b) {
	if(b==(long)0) {
		return a;
	}
	return GCD(b , a%b);
}
public static boolean good3() {
	return GCD(st3.gcd.peek(),st4.gcd.peek())==1;
}
public static long shortest_Segment_gcd_equal_to_one(long[] a,int n) {
	int l=0;
	long x=0;
	long res=Integer.MAX_VALUE;
	for(int r=0;r<n;r++) {
		add2(a[r]);
		while(good2()) {
		remove2();
			l++;
		}
		if(good3()) {
			res=Math.min(res, r-l+1);
		}
	}
	return res;
}
public static long[] merge_sort(long[] A, int start, int end) {
	if (end > start) {
		int mid = (end + start) / 2;
		long[] v = merge_sort(A, start, mid);
		long[] o = merge_sort(A, mid + 1, end);
		return (merge(v, o));
	} else {
		long[] y = new long[1];
		y[0] = A[start];
		return y;
	}
}
public static long[] merge(long a[], long b[]) {
//	int count=0;
	long[] temp = new long[a.length + b.length];
	int m = a.length;
	int n = b.length;
	int i = 0;
	int j = 0;
	int c = 0;
	while (i < m && j < n) {
		if (a[i] < b[j]) {
			temp[c++] = a[i++];
		
		} else {
			temp[c++] = b[j++];
		}
	}
	while (i < m) {
		temp[c++] = a[i++];
	}
	while (j < n) {
		temp[c++] = b[j++];
	}
	return temp;
}
public static pair4[] merge_sort(pair4[] A, int start, int end) {
	if (end > start) {
		int mid = (end + start) / 2;
		pair4[] v = merge_sort(A, start, mid);
		pair4[] o = merge_sort(A, mid + 1, end);
		return (merge(v, o));
	} else {
		pair4[] y = new pair4[1];
		y[0] = A[start];
		return y;
	}
}
public static pair4[] merge(pair4 a[], pair4 b[]) {
//	int count=0;
	pair4[] temp = new pair4[a.length + b.length];
	int m = a.length;
	int n = b.length;
	int i = 0;
	int j = 0;
	int c = 0;
	while (i < m && j < n) {
		if (a[i].b < b[j].b) {
			temp[c++] = a[i++];
		}else if(a[i].b==b[j].b) {
			if(a[i].a<b[j].a) {
				temp[c++]=a[i++];
			}else {
				temp[c++]=b[j++];
			}
		}
		else {
			temp[c++] = b[j++];
		}
	}
	while (i < m) {
		temp[c++] = a[i++];
	}
	while (j < n) {
		temp[c++] = b[j++];
	}
	return temp;
}



public static int[] Create(int[] a,int n) {
	int[] b=new int[n+1];
	for(int i=1;i<=n;i++) {
		int j=i;
		int h=a[i];
		while(i<=n) {
			b[i]+=h;
			i=get_next(i);
		}
		i=j;
	}
	return b;
}
public static int get_next(int a) {
return a+(a&-a);
}
public static int get_parent(int a) {
return a-(a&-a);
}
public static int query_1(int index) {
int sum=0;
if(index<=0) {
	return 0;
}
while(index>0) {
	sum+=t[index];
	index=get_parent(index);
}
return sum;
}
//public static int query(int n,int l,int r) {
//int sum=0;
//sum+=query_1(b,r);
//sum-=query_1(b,l-1);
//return sum;
//}
public static void update(int index,int n,int val) {
//int diff=val-a[index];
//a[index]+=diff;
while(index<=n) {
	t[index]+=val;
	index=get_next(index);
}	
}
}
