Bob is about to take a hot bath. 

There are two taps to fill the bath: a hot water tap and a cold water tap. The cold water's temperature is t1, and the hot water's temperature is t2. The cold water tap can transmit any integer number of water units per second from 0 to x1, inclusive. Similarly, the hot water tap can transmit from 0 to x2 water units per second.

If y1 water units per second flow through the first tap and y2 water units per second flow through the second tap, then the resulting bath water temperature will be:

<image>

Bob wants to open both taps so that the bath water temperature was not less than t0. However, the temperature should be as close as possible to this value. If there are several optimal variants, Bob chooses the one that lets fill the bath in the quickest way possible.

Determine how much each tap should be opened so that Bob was pleased with the result in the end.

Input

You are given five integers t1, t2, x1, x2 and t0 (1 ≤ t1 ≤ t0 ≤ t2 ≤ 106, 1 ≤ x1, x2 ≤ 106).

Output

Print two space-separated integers y1 and y2 (0 ≤ y1 ≤ x1, 0 ≤ y2 ≤ x2).

Examples

Input

10 70 100 100 25


Output

99 33

Input

300 500 1000 1000 300


Output

1000 0

Input

143 456 110 117 273


Output

76 54

Note

In the second sample the hot water tap shouldn't be opened, but the cold water tap should be opened at full capacity in order to fill the bath in the quickest way possible.
#include <bits/stdc++.h>
using namespace std;
typedef long long int64;
typedef unsigned long long uint64;
const double pi = acos(-1.0);
const double eps = 1e-11;
const int MAXI = 0x7fffffff;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
const char dz[] = "SENW";
void startDBG() {
  printf("%s", "\n\n------------------- Start Debug -------------------\n\n");
}
void endDBG() {
  printf("%s", "\n\n------------------- End Debug -------------------\n");
}
int in() {
  int x = 0, c;
  for (; (unsigned)((c = getchar()) - '0') >= 10;) {
    if (c == '-') return -in();
    if (!~c) throw ~0;
  }
  do {
    x = (x << 3) + (x << 1) + (c - '0');
  } while ((unsigned)((c = getchar()) - '0') < 10);
  return x;
}
int64 in64() {
  int64 x = 0, c;
  for (; (unsigned)((c = getchar()) - '0') >= 10;) {
    if (c == '-') return -in();
    if (!~c) throw ~0;
  }
  do {
    x = (x << 3) + (x << 1) + (c - '0');
  } while ((unsigned)((c = getchar()) - '0') < 10);
  return x;
}
void showVi(vector<int> A) {
  for (int i = (0), _b = (A.size()); i < _b; i++) cout << A[i] << " ";
}
void showVii(vector<pair<int, int> > A) {
  for (int i = (0), _b = (A.size()); i < _b; i++)
    cout << A[i].first << " " << A[i].second << endl;
}
void showVs(vector<string> A) {
  for (int i = (0), _b = (A.size()); i < _b; i++) cout << A[i] << endl;
}
void showArray(int A[], int n) {
  for (int i = (0), _b = (n); i < _b; i++) cout << A[i] << " ";
}
int MUOI(int x) {
  int re = 1;
  for (int i = (0), _b = (x); i < _b; i++) re *= 10;
  return re + x;
}
vector<int> getVi(int SOLUONG) {
  vector<int> REVI;
  for (int i = (0), _b = (SOLUONG); i < _b; i++) {
    int GETA;
    scanf("%d", &GETA);
    REVI.push_back(GETA);
  }
  return REVI;
}
vector<string> getVs(int SOLUONG) {
  vector<string> REVS;
  for (int i = (0), _b = (SOLUONG); i < _b; i++) {
    string GETS;
    cin >> GETS;
    REVS.push_back(GETS);
  }
  return REVS;
}
vector<pair<int, int> > getVii(int SOLUONG) {
  vector<pair<int, int> > REVII;
  for (int i = (0), _b = (SOLUONG); i < _b; i++) {
    int GETA, GETB;
    scanf("%d %d", &GETA, &GETB);
    REVII.push_back(make_pair(GETA, GETB));
  }
  return REVII;
}
template <class T>
inline T checkMod(T n, T m) {
  return (n % m + m) % m;
}
template <class T>
inline T multiplyMod(T a, T b, T m) {
  return (T)((((int64)(a) * (int64)(b) % (int64)(m)) + (int64)(m)) %
             (int64)(m));
}
template <class T>
inline T powerMod(T p, int e, T m) {
  if (e == 0)
    return 1 % m;
  else if (e % 2 == 0) {
    T t = powerMod(p, e / 2, m);
    return multiplyMod(t, t, m);
  } else
    return multiplyMod(powerMod(p, e - 1, m), p, m);
}
template <class T>
inline bool isPrimeNumber(T n) {
  if (n <= 1) return false;
  for (T i = 2; i * i <= n; i++)
    if (n % i == 0) return false;
  return true;
}
template <class T>
inline T sqr(T x) {
  return x * x;
}
template <class T>
inline T lowbit(T n) {
  return (n ^ (n - 1)) & n;
}
template <class T>
inline int countbit(T n) {
  return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
int64 C(int m, int n) {
  if (n > m) return 0;
  int64 re = 1;
  for (int i = 1; i <= n; i++) re = re * (m - i + 1) / i;
  return re;
}
template <class T>
inline T gcd(T a, T b) {
  if (a < 0) return gcd(-a, b);
  if (b < 0) return gcd(a, -b);
  return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
  if (a < 0) return lcm(-a, b);
  if (b < 0) return lcm(a, -b);
  return a * (b / gcd(a, b));
}
template <class T>
inline T euclide(T a, T b, T &x, T &y) {
  if (a < 0) {
    T d = euclide(-a, b, x, y);
    x = -x;
    return d;
  }
  if (b < 0) {
    T d = euclide(a, -b, x, y);
    y = -y;
    return d;
  }
  if (b == 0) {
    x = 1;
    y = 0;
    return a;
  } else {
    T d = euclide(b, a % b, x, y);
    T t = x;
    x = y;
    y = t - (a / b) * y;
    return d;
  }
}
template <class T>
inline vector<pair<T, int> > factorize(T n) {
  vector<pair<T, int> > R;
  for (T i = 2; n > 1;) {
    if (n % i == 0) {
      int C = 0;
      for (; n % i == 0; C++, n /= i)
        ;
      R.push_back(make_pair(i, C));
    }
    i++;
    if (i > n / i) i = n;
  }
  if (n > 1) R.push_back(make_pair(n, 1));
  return R;
}
template <class T>
inline T eularFunction(T n) {
  vector<pair<T, int> > R = factorize(n);
  T r = n;
  for (int i = 0; i < R.size(); i++) r = r / R[i].first * (R[i].first - 1);
  return r;
}
const int MaxMatrixSize = 40;
template <class T>
inline void showMatrix(int n, T A[MaxMatrixSize][MaxMatrixSize]) {
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) cout << A[i][j];
    cout << endl;
  }
}
template <class T>
inline void identityMatrix(int n, T A[MaxMatrixSize][MaxMatrixSize]) {
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) A[i][j] = (i == j) ? 1 : 0;
}
template <class T>
inline void addMatrix(int n, T C[MaxMatrixSize][MaxMatrixSize],
                      T A[MaxMatrixSize][MaxMatrixSize],
                      T B[MaxMatrixSize][MaxMatrixSize]) {
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) C[i][j] = A[i][j] + B[i][j];
}
template <class T>
inline void subMatrix(int n, T C[MaxMatrixSize][MaxMatrixSize],
                      T A[MaxMatrixSize][MaxMatrixSize],
                      T B[MaxMatrixSize][MaxMatrixSize]) {
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) C[i][j] = A[i][j] - B[i][j];
}
template <class T>
inline void mulMatrix(int n, T C[MaxMatrixSize][MaxMatrixSize],
                      T _A[MaxMatrixSize][MaxMatrixSize],
                      T _B[MaxMatrixSize][MaxMatrixSize]) {
  T A[MaxMatrixSize][MaxMatrixSize], B[MaxMatrixSize][MaxMatrixSize];
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
      A[i][j] = _A[i][j], B[i][j] = _B[i][j], C[i][j] = 0;
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
      for (int k = 0; k < n; k++) C[i][j] += A[i][k] * B[k][j];
}
template <class T>
inline void addModMatrix(int n, T m, T C[MaxMatrixSize][MaxMatrixSize],
                         T A[MaxMatrixSize][MaxMatrixSize],
                         T B[MaxMatrixSize][MaxMatrixSize]) {
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) C[i][j] = checkMod(A[i][j] + B[i][j], m);
}
template <class T>
inline void subModMatrix(int n, T m, T C[MaxMatrixSize][MaxMatrixSize],
                         T A[MaxMatrixSize][MaxMatrixSize],
                         T B[MaxMatrixSize][MaxMatrixSize]) {
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) C[i][j] = checkMod(A[i][j] - B[i][j], m);
}
template <class T>
inline void mulModMatrix(int n, T m, T C[MaxMatrixSize][MaxMatrixSize],
                         T _A[MaxMatrixSize][MaxMatrixSize],
                         T _B[MaxMatrixSize][MaxMatrixSize]) {
  T A[MaxMatrixSize][MaxMatrixSize], B[MaxMatrixSize][MaxMatrixSize];
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
      A[i][j] = _A[i][j], B[i][j] = _B[i][j], C[i][j] = 0;
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
      for (int k = 0; k < n; k++)
        C[i][j] = (C[i][j] + multiplyMod(A[i][k], B[k][j], m)) % m;
}
double dist(pair<int, int> a, pair<int, int> b) {
  return sqrt(sqr((double)(a.first) - (double)(b.first)) +
              sqr((double)(a.second) - (double)(b.second)));
}
double distR(pair<int, int> a, pair<int, int> b) {
  return sqr((double)(a.first) - (double)(b.first)) +
         sqr((double)(a.second) - (double)(b.second));
}
int cross(pair<int, int> c, pair<int, int> a, pair<int, int> b) {
  return (a.first - c.first) * (b.second - c.second) -
         (b.first - c.first) * (a.second - c.second);
}
int crossOper(pair<int, int> c, pair<int, int> a, pair<int, int> b) {
  double t = (a.first - c.first) * (b.second - c.second) -
             (b.first - c.first) * (a.second - c.second);
  if (fabs(t) <= eps) return 0;
  return (t < 0) ? -1 : 1;
}
bool isIntersect(pair<int, int> a, pair<int, int> b, pair<int, int> c,
                 pair<int, int> d) {
  return crossOper(a, b, c) * crossOper(a, b, d) < 0 &&
         crossOper(c, d, a) * crossOper(c, d, b) < 0;
}
bool isMiddle(double s, double m, double t) {
  return fabs(s - m) <= eps | fabs(t - m) <= eps | (s < m) != (t < m);
}
bool isUpperCase(char c) { return c >= 'A' && c <= 'Z'; }
bool isLowerCase(char c) { return c >= 'a' && c <= 'z'; }
bool isLetter(char c) { return c >= 'A' && c <= 'Z' | c >= 'a' && c <= 'z'; }
bool isDigit(char c) { return c >= '0' && c <= '9'; }
char toLowerCase(char c) { return (isUpperCase(c)) ? (c + 32) : c; }
char toUpperCase(char c) { return (isLowerCase(c)) ? (c - 32) : c; }
template <class T>
string toString(T n) {
  ostringstream ost;
  ost << n;
  ost.flush();
  return ost.str();
}
int toInt(string s) {
  int r = 0;
  istringstream sin(s);
  sin >> r;
  return r;
}
int64 toInt64(string s) {
  int64 r = 0;
  istringstream sin(s);
  sin >> r;
  return r;
}
double toDouble(string s) {
  double r = 0;
  istringstream sin(s);
  sin >> r;
  return r;
}
template <class T>
void stoa(string s, int &n, T A[]) {
  n = 0;
  istringstream sin(s);
  for (T v; sin >> v; A[n++] = v)
    ;
}
template <class T>
void atos(int n, T A[], string &s) {
  ostringstream sout;
  for (int i = 0; i < n; i++) {
    if (i > 0) sout << ' ';
    sout << A[i];
  }
  s = sout.str();
}
template <class T>
void atov(int n, T A[], vector<T> &vector<int>) {
  vector<int>.clear();
  for (int i = 0; i < n; i++) vector<int>.push_back(A[i]);
}
template <class T>
void vtoa(vector<T> vector<int>, int &n, T A[]) {
  n = vector<int>.size();
  for (int i = 0; i < n; i++) A[i] = vector<int>[i];
}
template <class T>
void stov(string s, vector<T> &vector<int>) {
  vector<int>.clear();
  istringstream sin(s);
  for (T v; sin >> v; vector<int>.push_back(v))
    ;
}
template <class T>
void vtos(vector<T> vector<int>, string &s) {
  ostringstream sout;
  for (int i = 0; i < vector<int>.size(); i++) {
    if (i > 0) sout << ' ';
    sout << vector<int>[i];
  }
  s = sout.str();
}
template <class T>
struct Fraction {
  T a, b;
  Fraction(T a = 0, T b = 1);
  string toString();
};
template <class T>
Fraction<T>::Fraction(T a, T b) {
  T d = gcd(a, b);
  a /= d;
  b /= d;
  if (b < 0) a = -a, b = -b;
  this->a = a;
  this->b = b;
}
template <class T>
string Fraction<T>::toString() {
  ostringstream sout;
  sout << a << "/" << b;
  return sout.str();
}
template <class T>
Fraction<T> operator+(Fraction<T> p, Fraction<T> q) {
  return Fraction<T>(p.a * q.b + q.a * p.b, p.b * q.b);
}
template <class T>
Fraction<T> operator-(Fraction<T> p, Fraction<T> q) {
  return Fraction<T>(p.a * q.b - q.a * p.b, p.b * q.b);
}
template <class T>
Fraction<T> operator*(Fraction<T> p, Fraction<T> q) {
  return Fraction<T>(p.a * q.a, p.b * q.b);
}
template <class T>
Fraction<T> operator/(Fraction<T> p, Fraction<T> q) {
  return Fraction<T>(p.a * q.b, p.b * q.a);
}
int t1 = in(), t2 = in(), x1 = in(), x2 = in(), t0 = in();
double chk(int y1, int y2) {
  double re = ((double)(y1) * (double)(t1) + (double)(y2) * (double)(t2)) /
              ((double)(y1) + (double)(y2));
  return (double)((double)(re) - (double)(t0));
}
int main() {
  if (t1 == t2) {
    if (x1 > x2)
      printf("0 %d", x2);
    else
      printf("%d 0", x1);
    return 0;
  }
  if (t1 == t0 || (t1 > t0 && t2 > t0 && t1 < t2) ||
      (t1 < t0 && t2 < t0 && t1 > t2)) {
    printf("%d 0", x1);
    return 0;
  }
  if (t2 == t0 || (t1 > t0 && t2 > t0 && t2 > t1) ||
      (t1 < t0 && t2 < t0 && t1 < t2)) {
    printf("0 %d", x2);
    return 0;
  }
  double thuong = (double)(t2 - t0) / (double)(t0 - t1);
  int re1, re2, maxVal = -MAXI;
  double minVal = MAXI;
  for (int i = (0), _b = (x2); i < _b; i++) {
    double tam = (double)(i)*thuong;
    double val = chk((int)(tam), (int)(i));
    if ((int)(tam) >= 0 && (int)(tam) <= x1 && minVal >= val &&
        maxVal < (int)(tam) + (int)(i)) {
      minVal = val;
      maxVal = (int)(tam) + (int)(i);
      re2 = i;
      re1 = (int)(tam);
    }
  }
  printf("%d %d", re1, re2);
}
