Problem: The scientists have recently discovered wormholes — objects in space that allow to travel very long distances between galaxies and star systems. 

The scientists know that there are n galaxies within reach. You are in the galaxy number 1 and you need to get to the galaxy number n. To get from galaxy i to galaxy j, you need to fly onto a wormhole (i, j) and in exactly one galaxy day you will find yourself in galaxy j. 

Unfortunately, the required wormhole is not always available. Every galaxy day they disappear and appear at random. However, the state of wormholes does not change within one galaxy day. A wormhole from galaxy i to galaxy j exists during each galaxy day taken separately with probability pij. You can always find out what wormholes exist at the given moment. At each moment you can either travel to another galaxy through one of wormholes that exist at this moment or you can simply wait for one galaxy day to see which wormholes will lead from your current position at the next day.

Your task is to find the expected value of time needed to travel from galaxy 1 to galaxy n, if you act in the optimal way. It is guaranteed that this expected value exists.

Input

The first line of the input contains a single integer n (1 ≤ n ≤ 1000) — the number of galaxies within reach.

Then follows a matrix of n rows and n columns. Each element pij represents the probability that there is a wormhole from galaxy i to galaxy j. All the probabilities are given in percents and are integers. It is guaranteed that all the elements on the main diagonal are equal to 100.

Output

Print a single real value — the expected value of the time needed to travel from galaxy 1 to galaxy n if one acts in an optimal way. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6. 

Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.

Examples

Input

3
100 50 50
0 100 80
0 0 100


Output

1.750000000000000


Input

2
100 30
40 100


Output

3.333333333333333

Note

In the second sample the wormhole from galaxy 1 to galaxy 2 appears every day with probability equal to 0.3. The expected value of days one needs to wait before this event occurs is <image>.

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.PriorityQueue;

public class C335Div1EIntGal {
	static int N;
	static int[][] P; // the probability array
	static boolean[][] RP; // the probability array
	static double[] D;
	static HNode[] nodes;
	static boolean[] Fix;
	static double eps = 1e-7;
	static PriorityQueue<HNode> heap = new PriorityQueue<>();
//	static int[] H;// the heap
//	static int hlen;
	public static void main(String[] args){
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		try {
			N = Integer.parseInt(br.readLine());
			P  = new int[N][N];
			RP = new boolean[N][N];
			D = new double[N];
			nodes = new HNode[N];
			Fix = new boolean[N];
//			H = new int[N];
			String[] chunks;
			for(int i = 0; i < N; i++){
				chunks = br.readLine().split(" ");
				for(int j = 0; j < N; j++){
					P[i][j] = Integer.parseInt(chunks[j]);
					if(P[i][j] > 0 && i!= j) RP[j][i] = true;
				}
			}
			if(N == 1){
				System.out.println(0);
				return;
			}			
//			for(int i = 0; i < N; i++){
//				System.out.println(Arrays.toString(P[i]));
//			}
			for(int i = 0; i < N-1; i++){
				if(RP[N-1][i]){
					D[i] = (double)100/ (double)P[i][N-1];
					nodes[i] =  new HNode(D[i], i,1, (1.0- (double)P[i][N-1]/(double)100));
					heap.add(nodes[i]);
				} else {
					D[i] = Double.MAX_VALUE;
					nodes[i] =  new HNode(D[i], i,1, 1);
				}
			}
			HNode minHeap;
			while(!heap.isEmpty()){
				minHeap = heap.remove();
				
//				System.out.println("min: " + minHeap.toString());
				if(minHeap.id == 0){
					System.out.println(minHeap.dis);
					break;
				}
				Fix[minHeap.id] = true;
				for(int j = 0; j < N-1; j++){
					if(RP[minHeap.id][j] && !Fix[j]){ // j is the parent of min heap
//						System.out.println("parent: " +j );
						// update j
//						double jdis = nodes[j].dis;
						double p = (double) P[j][minHeap.id]/ (double)100;
						nodes[j].a  = nodes[j].a + nodes[j].b*p*minHeap.dis;
						nodes[j].b = nodes[j].b*(1-p);
						double newDis = nodes[j].a / (1-nodes[j].b);
						heap.remove(nodes[j]);
						nodes[j].dis = newDis;
						heap.add(nodes[j]);
					}
				}
				
			}
//			System.out.println(Arrays.toString(D));
//			System.out.println(heap.toString());
		}catch(IOException ioe){
			ioe.printStackTrace();
		}
//		int[] A = {4,3,5,1,2,12,110,6,7,9,4};
//		for(int i = 0; i < A.length; i++)heap.add(A[i]);
//		System.out.println(heap.toString());
//		int[] B = buildHeap(A);
//		hlen = B.length;
//		System.out.println(Arrays.toString(B));
//		System.out.println(extractMin(B));
//		System.out.println(Arrays.toString(B));
//		
	}
	
//	static int extractMin(int B[]){
//		int rv = B[0];
//		B[0] = B[hlen-1];
//		B[hlen-1] = -1;
//		hlen--;
//		downHeap(B, 0, hlen);
//		return rv;
//	}
//	static int[] buildHeap(int[] A){
//		int[] B = new int[A.length];
//		for(int i = 0; i < A.length; i++){
//			B[i] = A[i];
//		}
//		int p;
//		for(int i = A.length-1; i >=1; i--){
//			p = ((i&1) == 0? (i-2)>>1: (i-1) >> 1);
//			if(B[p] > B[i]){
//				int tmp = B[p];
//				B[p] = B[i];
//				B[i] = tmp;
//				downHeap(B, i, A.length);
//			}
//		}
//		return B;
//	}
//	static void downHeap(int B[], int i, int hlen){
//		int l = (i << 1) + 1;
//		int r = (i << +2);
//		if(l < hlen && r < hlen){
//			int x = B[l];
//			int id = l;
//			if(B[r] < B[l]){
//				id = r;
//				x = B[r];
//			}
//			if(x < B[i]){
//				B[id] = B[i];
//				B[i] = x;
//				downHeap(B, id, hlen);
//			}
//		} else if(l < hlen){
//			if(B[l] < B[i]){
//				int tmp = B[i];
//				B[i] = B[l];
//				B[l] = tmp;
//			}
//		} else if(r < hlen){
//			if(B[r] < B[i]){
//				int tmp = B[i];
//				B[i] = B[r];
//				B[r] = tmp;
//			}
//		}
//	}
	
	static class HNode implements Comparable<HNode>{
		public double dis;
		public int id;
		public double a;
		public double b;
		
		public HNode(double dis, int id, double a, double b) {
			this.dis = dis;
			this.id = id;
			this.a  = a;
			this.b = b;
		}
		@Override
		public int compareTo(HNode o) {
			return Double.compare(dis, o.dis);
		}
		
		@Override
		public boolean equals(Object o){
			HNode x = (HNode)o;
			if(x.id == this.id) return true;
			else return false;
		}
		
		public String toString(){
			return "(" + dis + "," + id + "," + a + "," + b+ ")";
		}
		
	}

}


//test
//6
//100 0 0 25 0 0
//0 100 0 0 0 75
//0 0 100 0 0 0
//0 50 0 100 0 0
//0 0 0 0 100 0
//0 0 0 0 0 100
//output
//7.3333333333