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).
#include <bits/stdc++.h>
using namespace std;
long long bigprime = 999999733;
string dc(long long a, long long b) {
  cout << " (" << a << "," << b << ") -> ";
  string s = "";
  return s;
}
string dc(pair<long long, long long> a) {
  cout << " (" << a.first << "," << a.second << ") -> ";
  string s = "";
  return s;
}
void yes() { cout << "YES" << endl; }
void no() { cout << "NO" << endl; }
void Alice() { cout << "Alice" << endl; }
void Bob() { cout << "Bob" << endl; }
bool isPrime(long long n) {
  if (n == 2) return true;
  if (n == 1) return false;
  for (long long i = 2; i <= sqrt(n); i++)
    if (n % i == 0) return false;
  return true;
}
long long fillSegTree(long long cur, long long l, long long r,
                      vector<long long> &segtree, vector<long long> &arr) {
  long long n = arr.size();
  if (l == r && l < n) {
    segtree[cur] = arr[l];
    return segtree[cur];
  }
  if (l == r && l >= n) {
    segtree[cur] = INT_MAX;
    return segtree[cur];
  }
  long long left, right;
  left = fillSegTree(2 * cur + 1, l, (l + r) / 2, segtree, arr);
  right = fillSegTree(2 * cur + 2, (l + r) / 2 + 1, r, segtree, arr);
  segtree[cur] = min(left, right);
  return segtree[cur];
}
long long bataSegTree(long long cur, long long ql, long long qr, long long l,
                      long long r, vector<long long> &segtree) {
  if (ql <= l && r <= qr) {
    return segtree[cur];
  } else if (r < ql || qr < l) {
    return INT_MAX;
  } else {
    long long left, right, mid;
    mid = (l + r) / 2;
    left = bataSegTree(2 * cur + 1, ql, qr, l, mid, segtree);
    right = bataSegTree(2 * cur + 2, ql, qr, mid + 1, r, segtree);
    return min(left, right);
  }
}
void update_SegTree(long long cur, vector<long long> &segtree) {
  if (cur < 0) return;
  long long left = segtree[2 * cur + 1];
  long long right = segtree[2 * cur + 2];
  segtree[cur] = min(left, right);
  long long parent = (cur - 1) / 2;
  if (parent != 0) update_SegTree(parent, segtree);
}
bool inGrid(long long i, long long j, long long n, long long m) {
  if (i < 0 || j < 0 || i >= n || j >= m) return false;
  return true;
}
long long digsum(long long num) {
  long long sum = 0;
  while (num > 0) {
    sum += num % 10;
    num /= 10;
  }
  return sum;
}
void topo_dfs(long long cur, stack<long long> &st,
              unordered_map<long long, vector<long long>> &mp,
              unordered_set<long long> &vis) {
  vis.insert(cur);
  for (long long i = 0; i < mp[cur].size(); i++) {
    long long nex = mp[cur][i];
    if (!vis.count(nex)) topo_dfs(nex, st, mp, vis);
  }
  st.push(cur);
}
vector<long long> topoSort(unordered_map<long long, vector<long long>> &mp) {
  stack<long long> s;
  unordered_set<long long> vis;
  for (auto it = mp.begin(); it != mp.end(); it++) {
    long long cur = it->first;
    if (!vis.count(cur)) topo_dfs(cur, s, mp, vis);
  }
  vector<long long> ans;
  while (!s.empty()) {
    ans.push_back(s.top());
    s.pop();
  }
  return ans;
}
bool CYCLE_dfs(long long s, unordered_map<long long, vector<long long>> &adj,
               unordered_set<long long> &gray,
               unordered_set<long long> &black) {
  if (gray.count(s)) return true;
  if (black.count(s)) return false;
  gray.insert(s);
  for (long long i = 0; i < adj[s].size(); i++) {
    long long nex = adj[s][i];
    if (CYCLE_dfs(nex, adj, gray, black)) return true;
  }
  gray.erase(s);
  black.insert(s);
  return false;
}
bool isCyclic(unordered_map<long long, vector<long long>> &adj) {
  unordered_set<long long> gray;
  unordered_set<long long> black;
  vector<long long> white;
  for (auto it = adj.begin(); it != adj.end(); it++) {
    long long w = it->first;
    white.push_back(w);
  }
  for (long long p = 0; p < white.size(); p++) {
    long long i = white[p];
    if (!gray.count(i) && !black.count(i)) {
      if (CYCLE_dfs(i, adj, gray, black)) return true;
    }
  }
  return false;
}
bool compstd(pair<long long, long long> l, pair<long long, long long> r) {
  return l.first > r.first;
}
signed main() {
  long long sx, sy, dx, dy;
  cin >> sx >> sy >> dx >> dy;
  long long n;
  cin >> n;
  string s;
  cin >> s;
  vector<long long> psx(n, 0), psy(n, 0);
  for (long long i = 0; i < n; i++) {
    if (i != 0) psx[i] = psx[i - 1];
    if (i != 0) psy[i] = psy[i - 1];
    if (s[i] == 'L') psx[i]--;
    if (s[i] == 'D') psy[i]--;
    if (s[i] == 'R') psx[i]++;
    if (s[i] == 'U') psy[i]++;
  }
  long long l = 0, r = 1e18, m;
  long long ans = -1;
  while (l <= r) {
    m = (l + r) / 2;
    long long k = m;
    long long xx = (k % n != 0) ? psx[k % n - 1] : 0;
    long long yy = (k % n != 0) ? psy[k % n - 1] : 0;
    long long nx = sx + (k / n) * psx[n - 1] + xx;
    long long ny = sy + (k / n) * psy[n - 1] + yy;
    long long diff = abs(nx - dx) + abs(ny - dy);
    if (diff <= m) {
      ans = m;
      r = m - 1;
    } else
      l = m + 1;
  }
  cout << ans << endl;
  return 0;
}
