You a captain of a ship. Initially you are standing in a point (x_1, y_1) (obviously, all positions in the sea can be described by cartesian plane) and you want to travel to a point (x_2, y_2). 

You know the weather forecast — the string s of length n, consisting only of letters U, D, L and R. The letter corresponds to a direction of wind. Moreover, the forecast is periodic, e.g. the first day wind blows to the side s_1, the second day — s_2, the n-th day — s_n and (n+1)-th day — s_1 again and so on. 

Ship coordinates change the following way:

  * if wind blows the direction U, then the ship moves from (x, y) to (x, y + 1); 
  * if wind blows the direction D, then the ship moves from (x, y) to (x, y - 1); 
  * if wind blows the direction L, then the ship moves from (x, y) to (x - 1, y); 
  * if wind blows the direction R, then the ship moves from (x, y) to (x + 1, y). 



The ship can also either go one of the four directions or stay in place each day. If it goes then it's exactly 1 unit of distance. Transpositions of the ship and the wind add up. If the ship stays in place, then only the direction of wind counts. For example, if wind blows the direction U and the ship moves the direction L, then from point (x, y) it will move to the point (x - 1, y + 1), and if it goes the direction U, then it will move to the point (x, y + 2).

You task is to determine the minimal number of days required for the ship to reach the point (x_2, y_2).

Input

The first line contains two integers x_1, y_1 (0 ≤ x_1, y_1 ≤ 10^9) — the initial coordinates of the ship.

The second line contains two integers x_2, y_2 (0 ≤ x_2, y_2 ≤ 10^9) — the coordinates of the destination point.

It is guaranteed that the initial coordinates and destination point coordinates are different.

The third line contains a single integer n (1 ≤ n ≤ 10^5) — the length of the string s.

The fourth line contains the string s itself, consisting only of letters U, D, L and R.

Output

The only line should contain the minimal number of days required for the ship to reach the point (x_2, y_2).

If it's impossible then print "-1".

Examples

Input


0 0
4 6
3
UUU


Output


5


Input


0 3
0 0
3
UDD


Output


3


Input


0 0
0 1
1
L


Output


-1

Note

In the first example the ship should perform the following sequence of moves: "RRRRU". Then its coordinates will change accordingly: (0, 0) → (1, 1) → (2, 2) → (3, 3) → (4, 4) → (4, 6).

In the second example the ship should perform the following sequence of moves: "DD" (the third day it should stay in place). Then its coordinates will change accordingly: (0, 3) → (0, 3) → (0, 1) → (0, 0).

In the third example the ship can never reach the point (0, 1).
import java.io.*;
import java.util.*;

public class Main {
	static long mod=1000000007;
	public static void main(String[] args){
		long x0=nl(),y0=nl();
		long x1=nl(),y1=nl();
		int n=ni();
		String str=next();
		x1-=x0;
		y1-=y0;
		//(x+y,x-y)
		long X=x1+y1;
		long Y=x1-y1;
		
		long sX=0,sY=0;
		for(int i=0;i<n;i++){
			char ch=str.charAt(i);
			if(ch=='U'){
				//sy++;
				sX++;
				sY--;
			}
			if(ch=='D'){
				//sy--;
				sX--;
				sY++;
			}
			if(ch=='L'){
				//sx--;
				sX--;
				sY--;
			}
			if(ch=='R'){
				//sx++;
				sX++;
				sY++;
			}
		}
		
		long res=Long.MAX_VALUE/10;
		int cx=0,cy=0;
		for(int i=0;i<n;i++){
			char ch=str.charAt(i);
			if(ch=='U'){
				//sy++;
				cx++;
				cy--;
			}
			if(ch=='D'){
				//sy--;
				cx--;
				cy++;
			}
			if(ch=='L'){
				//sx--;
				cx--;
				cy--;
			}
			if(ch=='R'){
				//sx++;
				cx++;
				cy++;
			}
			
			int ido=i+1;
			if(dist(cx,cy,X,Y)<=ido){
				res=Math.min(res,ido);
			}
			if(cx==X && cy==Y) continue;
			long kai1=kai(cx,sX,X,n,ido);
			long kai2=kai(cy,sY,Y,n,ido);
			long ka=Math.max(kai1,kai2);
			res=Math.min(res,ka+ido);
		}
		if(res>Long.MAX_VALUE/20) pl(-1);
		else pl(res);
		flush();
	}
	static long kai(long cx,long sX,long X,long n,int ido){
		if(cx>X) return kai(-cx,-sX,-X,n,ido);
		X-=ido;
		X=Math.max(X,cx);
		if(cx==X) return 0;
		if(sX<0){
			if(n+sX <=0) return Long.MAX_VALUE/10;
			long nx=cx+n+sX;
			if(nx>X) nx=X;
			long sh=(X-cx)-(X-nx);
			long kai=(X-cx)/sh+((X-cx)%sh==0?0:1);
			return kai*n;
		}else{
			long nx=cx+n+sX;
			if(nx>X) nx=X;
			long sh=(X-cx)-(X-nx);
			long kai=(X-cx)/sh+((X-cx)%sh==0?0:1);
			return kai*n;
		}
	}
	static long dist(long x0,long y0,long x1,long y1){
		return Math.max(Math.abs(x0-x1),Math.abs(y0-y1));
	}
    
    
    
    
    
	private static final byte[] buffer = new byte[1024];
	private static int ptr = 0;
	private static int buflen = 0;
	private static boolean hasNextByte() {
		if (ptr < buflen)  return true;
		else{
			ptr = 0;
			try {
				buflen = System.in.read(buffer);
			} catch (IOException e) {e.printStackTrace();}
			if (buflen <= 0)  return false;
		}
		return true;
	}
	private static int readByte() { return hasNextByte() ? buffer[ptr++] : -1;}
	private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
	private static void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
	public static boolean hasNext() { skipUnprintable(); return hasNextByte();}
	public static String next() {
		if (!hasNext()) throw new NoSuchElementException();
		StringBuilder sb = new StringBuilder();
		for(int b = readByte();isPrintableChar(b);b = readByte()) {
			sb.appendCodePoint(b);
		}
		return sb.toString();
	}
	public static int nextInt() {return (int)nextLong();}
	public static long nextLong() {
		if (!hasNext()) throw new NoSuchElementException();
		long n = 0;
		boolean minus = false;
		int b = readByte();
		if (b == '-') {
			minus = true;
			b = readByte();
		}
		if (b < '0' || '9' < b)  throw new NumberFormatException();
		while(true){
			if ('0' <= b && b <= '9') n = n * 10 + b-'0';
			else if(b == -1 || !isPrintableChar(b)) return minus ? -n : n;
			else throw new NumberFormatException();
			b = readByte();
		}
	}
	public static long[] nextLongArray(int i){
		long[] result=new long[i];
		for(int j=0;j<i;j++)  result[j]=nextLong();
		return result;
	}
	public static void nextLongArray(long[]... arrays){
		for(int j=0;j<arrays[0].length;j++)
			for(long[] array:arrays) array[j]=nextLong();
	}
	public static int[] nextIntArray(int i){
		int[] result=new int[i];
		for(int j=0;j<i;j++)  result[j]=nextInt();
		return result;
	}
	public static void nextIntArray(int[]... arrays){
		for(int j=0;j<arrays[0].length;j++)
			for(int[] array:arrays)  array[j]=nextInt();
	}
	public static int ni(){return nextInt();}
	public static long nl(){return nextLong();}
	public static int[] nia(int n){return nextIntArray(n);}
	public static long[] nla(int n){return nextLongArray(n);}
	public static String ne(){return next();}
	
	static StringBuilder sb=new StringBuilder();
	public static void flush(){
		System.out.print(sb);
		sb=new StringBuilder();
	}
	public static void pr(Object o){sb.append(o);}
	public static void pl(Object o){sb.append(o).append("\n");}
	public static void pl(){sb.append("\n");}
	public static int lastLowerIndex(long[] array,long lo){return lastLowerOrEqualIndex(array,lo-1);}
	public static int lastLowerOrEqualIndex(long[] array,long lo){
		int res=Arrays.binarySearch(array,lo);
		return res<0?-res-2:res;
	}
	public static long gcd(long a,long b){
		if(a>b)a%=b;
		while(a>0){
			b%=a;
			if(b==0)return a;
			a%=b;
		}
		return b;
	}
	public static long modPow(long a,long b,long mod){
		long c=1;
		while(b>0){
			if(b%2==1)  c=(c*a)%mod;
			a=(a*a)%mod;
			b/=2;
		}
		return c;
	}
	public static long inv(long a,long mod){
		long b=mod;
		long p = 1, q = 0;
		while (b > 0) {
			long c = a / b;
			long d=a;
			a = b;
			b = d % b;
			d = p;
			p = q;
			q = d - c * q;
		}
		return p < 0 ? p + mod : p;
	}
	static long time=0;
	public static void time(){
		if(time==0) time=System.nanoTime();
		else{
			long t=System.nanoTime();
			pl((t-time)/1000000000.0+"sec");
			time=t;
		}
	}
	public static Integer[] sortedIndex(long[] a){
            Integer[] res=new Integer[a.length];
            for(int i=0;i<a.length;i++)	res[i]=i;
            mergesortIndex(res,a,0,a.length);
            return res;
        }
        private static Integer[] stem=new Integer[200005];
        private static void mergesortIndex(Integer[] index,long[] a, int s, int e){//uwi's
            if(e - s <= 1)return;
            int h = s+e>>1;
            mergesortIndex(index,a, s, h);
            mergesortIndex(index,a, h, e);
            int p = 0;
            int i= s, j = h;
            for(;i < h && j < e;)stem[p++] = a[(int)index[i]] < a[(int)index[j]] ? index[i++] : index[j++];
            while(i < h)stem[p++] = index[i++];
            while(j < e)stem[p++] = index[j++];
            System.arraycopy(stem, 0, index, s, e-s);
        }
        private static long[] stmp=new long[200005];
        private static void mergesort(long[] a, int s, int e){//uwi's
            if(e - s <= 1)return;
            int h = s+e>>1;
            mergesort(a, s, h);
            mergesort(a, h, e);
            int p = 0;
            int i= s, j = h;
            for(;i < h && j < e;)stmp[p++] = a[i] < a[j] ? a[i++] : a[j++];
            while(i < h)stmp[p++] = a[i++];
            while(j < e)stmp[p++] = a[j++];
            System.arraycopy(stmp, 0, a, s, e-s);
        }
}