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.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.*;
import java.util.concurrent.LinkedBlockingDeque;


public class scratch_25 {
    // int count=0;
    //static long count=0;
    static class Reader {
        static BufferedReader reader;
        static StringTokenizer tokenizer;

        /**
         * call this method to initialize reader for InputStream
         */
        static void init(InputStream input) {
            reader = new BufferedReader(
                    new InputStreamReader(input));
            tokenizer = new StringTokenizer("");
        }

        /**
         * get next word
         */
        static String next() throws IOException {
            while (!tokenizer.hasMoreTokens()) {
                //TODO add check for eof if necessary
                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());
        }
    }





    static class Pair implements Comparable<Pair>{
        long x;
        long y;
        public Pair(long x,long y){
            this.x=x;
            this.y=y;
        }
        @Override
        public int compareTo(Pair o){
            return (int)this.x-(int)o.x;


        }
        @Override
        public boolean equals(Object me) {
            Pair binMe = (Pair)me;
            if(this.x==binMe.x && this.y==binMe.y)
                return true;
            else
                return false;
        }

        @Override
        public int hashCode() {
            return (int)this.x + (int)this.y;
        }

        @Override
        public String toString() {
            return x+" "+y;
        }


    }







    public static void main(String[] args)  throws IOException {
        Reader.init(System.in);
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
        long x1= Reader.nextLong();
        long y1= Reader.nextLong();
        long x2= Reader.nextLong();
        long y2= Reader.nextLong();
        int len= Reader.nextInt();
        String dir= Reader.next();
        long l=0;
        long r=0;
        long u=0;
        long d=0;
        for (int i = 0; i <dir.length() ; i++) {
            if(dir.charAt(i)=='L'){
                l++;
            }
            if(dir.charAt(i)=='U'){
                u++;
            }
            if(dir.charAt(i)=='D'){
                d++;
            }
            if(dir.charAt(i)=='R'){
                r++;
            }
        }
        boolean left=true; // true means net left, false means net right
        boolean up=true;  // true means net up, false means net down
        if(x2>=x1){
            left=false;
        }
        if(y2<=y1){
            up=false;
        }
        long min=0;
        long max=(long)2e15;
        while(max-min>1){
            long mid= min+(max-min)/2;
                if(possible(mid,x1,y1,x2,y2,dir,l,u,d,r)){
                    max=mid;
                }
                else{
                    min=mid+1;
                }
        }
        if(!possible(min,x1,y1,x2,y2,dir,l,u,d,r)){
            min++;
        }
      //  System.out.println("ans="+possible((long)2e15,x1,y1,x2,y2,dir,l,u,d,r,left,up));
        if(!possible((long)2e15,x1,y1,x2,y2,dir,l,u,d,r)) {
            min = -1;
        }
        out.append(min+"\n");
        out.flush();
        out.close();

    }

    public static boolean possible(long mid, long x1, long y1,long x2, long y2, String dir,long l, long u, long d, long r){
        boolean b=false;
        long lt=0;
        long rt=0;
        long ut=0;
        long dt=0;

        long num=mid/dir.length();
        lt+=num*l;
        rt+=num*r;
        dt+=num*d;
        ut+=num*u;
    //    System.out.println("ut="+ut);
        long val=mid%(dir.length());
        for (int i = 0; i <val ; i++) {
            if(dir.charAt(i)=='L'){
                lt++;
            }
            if(dir.charAt(i)=='U'){
                ut++;
            }
            if(dir.charAt(i)=='D'){
                dt++;
            }
            if(dir.charAt(i)=='R'){
                rt++;
            }
        }
        x1=x1+rt-lt;
        y1=y1+ut-dt;
        boolean left=true;
        boolean up=true;
        if(x2>=x1){
            left=false;
        }
        if(y2<=y1){
            up=false;
        }

        long dx=Math.abs(x1-x2);
        long dy=Math.abs(y1-y2);
        if(dx+dy<=mid){
            b=true;
        }































return b;
    }























    public static ArrayList<Integer> Sieve(int n) {
        boolean arr[]= new boolean [n+1];
        Arrays.fill(arr,true);
        arr[0]=false;
        arr[1]=false;
        for (int i = 2; i*i <=n ; i++) {
            if(arr[i]){
                for (int j = 2; j <=n/i ; j++) {
                    int u= i*j;
                    arr[u]=false;
                }}
        }
        ArrayList<Integer> ans= new ArrayList<>();
        for (int i = 0; i <n+1 ; i++) {
            if(arr[i]){
                ans.add(i);
            }
        }
        return ans;
    }




    static long power( long x, long y, long p)
    {

        long res = 1;


        x = x % p;

        if (x == 0) return 0;

        while (y > 0)
        {

            if((y & 1)==1)
                res = (res * x) % p;


            y = y >> 1;
            x = (x * x) % p;
        }
        return res;
    }

    public static long ceil_div(long a, long b){
        return (a+b-1)/b;
    }

    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*b)/gcd(a, b);
    }

}