Two boys decided to compete in text typing on the site "Key races". During the competition, they have to type a text consisting of s characters. The first participant types one character in v1 milliseconds and has ping t1 milliseconds. The second participant types one character in v2 milliseconds and has ping t2 milliseconds.

If connection ping (delay) is t milliseconds, the competition passes for a participant as follows: 

  1. Exactly after t milliseconds after the start of the competition the participant receives the text to be entered. 
  2. Right after that he starts to type it. 
  3. Exactly t milliseconds after he ends typing all the text, the site receives information about it. 



The winner is the participant whose information on the success comes earlier. If the information comes from both participants at the same time, it is considered that there is a draw.

Given the length of the text and the information about participants, determine the result of the game.

Input

The first line contains five integers s, v1, v2, t1, t2 (1 ≤ s, v1, v2, t1, t2 ≤ 1000) — the number of characters in the text, the time of typing one character for the first participant, the time of typing one character for the the second participant, the ping of the first participant and the ping of the second participant.

Output

If the first participant wins, print "First". If the second participant wins, print "Second". In case of a draw print "Friendship".

Examples

Input

5 1 2 1 2


Output

First


Input

3 3 1 1 1


Output

Second


Input

4 5 3 1 5


Output

Friendship

Note

In the first example, information on the success of the first participant comes in 7 milliseconds, of the second participant — in 14 milliseconds. So, the first wins.

In the second example, information on the success of the first participant comes in 11 milliseconds, of the second participant — in 5 milliseconds. So, the second wins.

In the third example, information on the success of the first participant comes in 22 milliseconds, of the second participant — in 22 milliseconds. So, it is be a draw.
import java.util.*;
import java.io.*;
import java.math.*;
 public class Q1 {

	static ArrayList<Integer> adj[],adj2[];
	static int color[],cc;
	static long mod=1000000007;
	static TreeSet<Integer> ts;
	static boolean b[],visited[],possible,ans1,ans2;
	static Stack<Integer> s;
	static int totalnodes,colored,minc;
	static int c[],a[],n,parent[],ans[],size[];
	static long sum[];
	static TreeMap<Integer,TreeSet<Pair>> hm;
	public static void main(String[] args) throws IOException {
		
//	Scanner in=new Scanner(System.in);
		in=new InputReader(System.in);
		w=new PrintWriter(System.out);
		
		int n=in.nextInt();
		int v1=in.nextInt();
		int v2=in.nextInt();
		int t1=in.nextInt();
		int t2=in.nextInt();
		
		
		int a=t1+t1+(v1*n);
		int b=t2+t2+(v2*n);
		
		if(a>b)
			w.println("Second");
		else if(a==b)
			w.println("Friendship");
		else
			w.println("First");
		
		
		w.close();
					
	}
	static int fact(int f)
	{
		int ans=1;
		for(int i=1;i<=f;i++)
		{
			ans*=i;
		}
		return ans;
	}
	static int check(int m)
	{
		int c=0;
		for(int i=0;i<n-1;i++)
		{
			int l=i;
			int r=n-1;
			while(l<r)
			{
				int mid=(l+r)/2;
				
				if(a[i]+m+1>a[mid])
					l=mid+1;
				else
					r=mid;
			}
		//debug(" l****** "+l);
			if(!(a[l]-a[i]<=m))
			while(a[l]==a[l-1])
				l--;
			
		//	debug((l-1-(i)));
			if(l==n-1 && !(a[l]-a[i]>m) )
				c=c+l-i;
			else
			c=c+(l-1-(i));
		}
		
		return c;
	}
	static InputReader in;
	static PrintWriter w;
 	static void dfs(int i)
	{
 		 size[i]=1;int badabeta=0;
 		 for(int j=0;j<adj[i].size();j++)
 		 {
 			 int son=adj[i].get(j);
 			 dfs(son);
 			 size[i]+=size[son];
 			 
 			 if(size[son]>size[badabeta])
 				 badabeta=son;
 		 }
 		 if(size[badabeta]*2>size[i])
 		 {
 			 int dada = ans[badabeta];
 			 while((size[i]-size[dada])*2>size[i])
 				 dada=parent[dada];
 			 ans[i]=dada;
 		 }
		
	}
	public static void seive(long n){
		b = new boolean[(int) (n+1)];
	Arrays.fill(b, true);
	b[0]=false;
	b[1]=false;
		for(int i = 2;i*i<=n;i++){
			if(b[i]){
				for(int p = 2*i;p<=n;p+=i){
					b[p] = false;
				}
			}
		
		}
	}
 	static public class comp implements Comparator<Pair> 
 	{
 		 public int compare(Pair a,Pair b)
 	    {
 	     return (b.count-a.count);
 	    }
 	}
 	static class Pair implements Comparable<Pair> {
		char ch;
		int count;
		
		public Pair(){
			
		}
		public Pair(char u,int v) {
			this.ch=u;
			this.count=v;
			
		}
		public int compareTo(Pair other) {
			
			return 0;
		}
		
		/*public String toString() {
			return "[u=" + u + ", v=" + v + "]";
		}*/
	}
	static class Node2{
		Node2 left = null;
		Node2 right = null;
		Node2 parent = null;
		int data;
	}
	
	//binaryStree
	static class BinarySearchTree{
		Node2 root = null;
		int height = 0;
		int max = 0;
		int cnt = 1;
		ArrayList<Integer> parent = new ArrayList<>();
		HashMap<Integer, Integer> hm = new HashMap<>();
		public void insert(int x){
			Node2 n = new Node2();
			n.data = x;
			if(root==null){
				root = n;
			}
			else{
				Node2 temp = root,temp2 = null;
				while(temp!=null){
					temp2 = temp;
					if(x>temp.data) temp = temp.right;
					else temp = temp.left;
				}
				if(x>temp2.data) temp2.right = n;
				else temp2.left = n;
				n.parent = temp2;
				parent.add(temp2.data);
			}
		}
		public Node2 getSomething(int x, int y, Node2 n){
			if(n.data==x || n.data==y) return n;
			else if(n.data>x && n.data<y) return n;
			else if(n.data<x && n.data<y) return getSomething(x,y,n.right);
			else return getSomething(x,y,n.left);
		}
		public Node2 search(int x,Node2 n){
			if(x==n.data){
				max = Math.max(max, n.data);
				return n;
			}
			if(x>n.data){
				max = Math.max(max, n.data);
				return search(x,n.right);
			}
			else{
				max = Math.max(max, n.data);
				return search(x,n.left);
			}
		}
		public int getHeight(Node2 n){
			if(n==null) return 0;
			height = 1+ Math.max(getHeight(n.left), getHeight(n.right));
			return height;
		}
	}
public static void debug(Object... o) {
	System.out.println(Arrays.deepToString(o));
}

public static String rev(String s)
{
	StringBuilder sb=new StringBuilder(s);
	sb.reverse();
	return sb.toString();
}

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

static long gcd(long a, long b)
{
    while (b > 0)
    {
        long temp = b;
        b = a % b; // % is remainder
        a = temp;
    }
    return a;
}

public static long max(long x, long y, long z){
		if(x>=y && x>=z) return x;
		if(y>=x && y>=z) return y;
		return z;
	}
	static int[] sieve(int n,int[] arr)
	{
	for(int i=2;i*i<=n;i++)
	{
		if(arr[i]==0)
		{
			for(int j=i*2;j<=n;j+=i)
				arr[j]=1;
		}
	}
	return arr;
	}




static class InputReader {

private final InputStream stream;
private final byte[] buf = new byte[8192];
private int curChar, snumChars;
private SpaceCharFilter filter;

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

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

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

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

public int[] nextIntArray(int n) {
	 return nextIntArray(n, 0);
	    }
	    
public int[] nextIntArray(int n, int off) {
	 int[] arr = new int[n + off];
	   for (int i = 0; i < n; i++) {
	    arr[i + off] = nextInt();
	    }
	    return arr;
	    }
	    
public long[] nextLongArray(int n) {
return nextLongArray(n, 0);
	    }
        
	public long[] nextLongArray(int n, int off) {
	 long[] arr = new long[n + off];
	 for (int i = 0; i < n; i++) {
		  arr[i + off] = nextLong();
		 }
 return arr;
	}


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

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

public boolean isSpaceChar(int c) {
  if (filter != null)
    return filter.isSpaceChar(c);
  return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}

private boolean isEndOfLine(int c) {
  return c == '\n' || c == '\r' || c == -1;
}

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