The football season has just ended in Berland. According to the rules of Berland football, each match is played between two teams. The result of each match is either a draw, or a victory of one of the playing teams. If a team wins the match, it gets w points, and the opposing team gets 0 points. If the game results in a draw, both teams get d points.

The manager of the Berland capital team wants to summarize the results of the season, but, unfortunately, all information about the results of each match is lost. The manager only knows that the team has played n games and got p points for them.

You have to determine three integers x, y and z — the number of wins, draws and loses of the team. If there are multiple answers, print any of them. If there is no suitable triple (x, y, z), report about it.

Input

The first line contains four integers n, p, w and d (1 ≤ n ≤ 10^{12}, 0 ≤ p ≤ 10^{17}, 1 ≤ d < w ≤ 10^{5}) — the number of games, the number of points the team got, the number of points awarded for winning a match, and the number of points awarded for a draw, respectively. Note that w > d, so the number of points awarded for winning is strictly greater than the number of points awarded for draw.

Output

If there is no answer, print -1.

Otherwise print three non-negative integers x, y and z — the number of wins, draws and losses of the team. If there are multiple possible triples (x, y, z), print any of them. The numbers should meet the following conditions: 

  * x ⋅ w + y ⋅ d = p, 
  * x + y + z = n. 

Examples

Input


30 60 3 1


Output


17 9 4


Input


10 51 5 4


Output


-1


Input


20 0 15 5


Output


0 0 20

Note

One of the possible answers in the first example — 17 wins, 9 draws and 4 losses. Then the team got 17 ⋅ 3 + 9 ⋅ 1 = 60 points in 17 + 9 + 4 = 30 games.

In the second example the maximum possible score is 10 ⋅ 5 = 50. Since p = 51, there is no answer.

In the third example the team got 0 points, so all 20 games were lost.
#include <bits/stdc++.h>
using namespace std;
class DividedByZeroException {};
class BigInteger {
 private:
  vector<char> digits;
  bool sign;
  void trim();

 public:
  BigInteger(int);
  BigInteger(string&);
  BigInteger();
  BigInteger(const BigInteger&);
  BigInteger operator=(const BigInteger& op2);
  BigInteger abs() const;
  BigInteger pow(int a);
  friend BigInteger operator+=(BigInteger&, const BigInteger&);
  friend BigInteger operator-=(BigInteger&, const BigInteger&);
  friend BigInteger operator*=(BigInteger&, const BigInteger&);
  friend BigInteger operator/=(BigInteger&,
                               const BigInteger&) throw(DividedByZeroException);
  friend BigInteger operator%=(BigInteger&,
                               const BigInteger&) throw(DividedByZeroException);
  friend BigInteger operator+(const BigInteger&, const BigInteger&);
  friend BigInteger operator-(const BigInteger&, const BigInteger&);
  friend BigInteger operator*(const BigInteger&, const BigInteger&);
  friend BigInteger operator/(const BigInteger&,
                              const BigInteger&) throw(DividedByZeroException);
  friend BigInteger operator%(const BigInteger&,
                              const BigInteger&) throw(DividedByZeroException);
  friend BigInteger operator-(const BigInteger&);
  friend BigInteger operator++(BigInteger&);
  friend BigInteger operator++(BigInteger&, int);
  friend BigInteger operator--(BigInteger&);
  friend BigInteger operator--(BigInteger&, int);
  friend bool operator>(const BigInteger&, const BigInteger&);
  friend bool operator<(const BigInteger&, const BigInteger&);
  friend bool operator==(const BigInteger&, const BigInteger&);
  friend bool operator!=(const BigInteger&, const BigInteger&);
  friend bool operator>=(const BigInteger&, const BigInteger&);
  friend bool operator<=(const BigInteger&, const BigInteger&);
  friend ostream& operator<<(ostream&, const BigInteger&);
  friend istream& operator>>(istream&, BigInteger&);

 public:
  static const BigInteger ZERO;
  static const BigInteger ONE;
  static const BigInteger TEN;
};
const BigInteger BigInteger::ZERO = BigInteger(0);
const BigInteger BigInteger::ONE = BigInteger(1);
const BigInteger BigInteger::TEN = BigInteger(10);
BigInteger::BigInteger() { sign = true; }
BigInteger::BigInteger(int val) {
  if (val >= 0) {
    sign = true;
  } else {
    sign = false;
    val *= (-1);
  }
  do {
    digits.push_back((char)(val % 10));
    val /= 10;
  } while (val != 0);
}
BigInteger::BigInteger(string& def) {
  sign = true;
  for (string::reverse_iterator iter = def.rbegin(); iter < def.rend();
       iter++) {
    char ch = (*iter);
    if (iter == def.rend() - 1) {
      if (ch == '+') {
        break;
      }
      if (ch == '-') {
        sign = false;
        break;
      }
    }
    digits.push_back((char)((*iter) - '0'));
  }
  trim();
}
void BigInteger::trim() {
  vector<char>::reverse_iterator iter = digits.rbegin();
  while (!digits.empty() && (*iter) == 0) {
    digits.pop_back();
    iter = digits.rbegin();
  }
  if (digits.size() == 0) {
    sign = true;
    digits.push_back(0);
  }
}
BigInteger::BigInteger(const BigInteger& op2) {
  sign = op2.sign;
  digits = op2.digits;
}
BigInteger BigInteger::operator=(const BigInteger& op2) {
  digits = op2.digits;
  sign = op2.sign;
  return (*this);
}
BigInteger BigInteger::abs() const {
  if (sign) {
    return *this;
  } else {
    return -(*this);
  }
}
BigInteger BigInteger::pow(int a) {
  BigInteger res(1);
  for (int i = 0; i < a; i++) {
    res *= (*this);
  }
  return res;
}
BigInteger operator+=(BigInteger& op1, const BigInteger& op2) {
  if (op1.sign == op2.sign) {
    vector<char>::iterator iter1;
    vector<char>::const_iterator iter2;
    iter1 = op1.digits.begin();
    iter2 = op2.digits.begin();
    char to_add = 0;
    while (iter1 != op1.digits.end() && iter2 != op2.digits.end()) {
      (*iter1) = (*iter1) + (*iter2) + to_add;
      to_add = ((*iter1) > 9);
      (*iter1) = (*iter1) % 10;
      iter1++;
      iter2++;
    }
    while (iter1 != op1.digits.end()) {
      (*iter1) = (*iter1) + to_add;
      to_add = ((*iter1) > 9);
      (*iter1) %= 10;
      iter1++;
    }
    while (iter2 != op2.digits.end()) {
      char val = (*iter2) + to_add;
      to_add = (val > 9);
      val %= 10;
      op1.digits.push_back(val);
      iter2++;
    }
    if (to_add != 0) {
      op1.digits.push_back(to_add);
    }
    return op1;
  } else {
    if (op1.sign) {
      return op1 -= (-op2);
    } else {
      return op1 = op2 - (-op1);
    }
  }
}
BigInteger operator-=(BigInteger& op1, const BigInteger& op2) {
  if (op1.sign == op2.sign) {
    if (op1.sign) {
      if (op1 < op2) {
        return op1 = -(op2 - op1);
      }
    } else {
      if (-op1 > -op2) {
        return op1 = -((-op1) - (-op2));
      } else {
        return op1 = (-op2) - (-op1);
      }
    }
    vector<char>::iterator iter1;
    vector<char>::const_iterator iter2;
    iter1 = op1.digits.begin();
    iter2 = op2.digits.begin();
    char to_substract = 0;
    while (iter1 != op1.digits.end() && iter2 != op2.digits.end()) {
      (*iter1) = (*iter1) - (*iter2) - to_substract;
      to_substract = 0;
      if ((*iter1) < 0) {
        to_substract = 1;
        (*iter1) += 10;
      }
      iter1++;
      iter2++;
    }
    while (iter1 != op1.digits.end()) {
      (*iter1) = (*iter1) - to_substract;
      to_substract = 0;
      if ((*iter1) < 0) {
        to_substract = 1;
        (*iter1) += 10;
      } else {
        break;
      }
      iter1++;
    }
    op1.trim();
    return op1;
  } else {
    if (op1 > BigInteger::ZERO) {
      return op1 += (-op2);
    } else {
      return op1 = -(op2 + (-op1));
    }
  }
}
BigInteger operator*=(BigInteger& op1, const BigInteger& op2) {
  BigInteger result(0);
  if (op1 == BigInteger::ZERO || op2 == BigInteger::ZERO) {
    result = BigInteger::ZERO;
  } else {
    vector<char>::const_iterator iter2 = op2.digits.begin();
    while (iter2 != op2.digits.end()) {
      if (*iter2 != 0) {
        deque<char> temp(op1.digits.begin(), op1.digits.end());
        char to_add = 0;
        deque<char>::iterator iter1 = temp.begin();
        while (iter1 != temp.end()) {
          (*iter1) *= (*iter2);
          (*iter1) += to_add;
          to_add = (*iter1) / 10;
          (*iter1) %= 10;
          iter1++;
        }
        if (to_add != 0) {
          temp.push_back(to_add);
        }
        int num_of_zeros = iter2 - op2.digits.begin();
        while (num_of_zeros--) {
          temp.push_front(0);
        }
        BigInteger temp2;
        temp2.digits.insert(temp2.digits.end(), temp.begin(), temp.end());
        temp2.trim();
        result = result + temp2;
      }
      iter2++;
    }
    result.sign = ((op1.sign && op2.sign) || (!op1.sign && !op2.sign));
  }
  op1 = result;
  return op1;
}
BigInteger operator/=(BigInteger& op1,
                      const BigInteger& op2) throw(DividedByZeroException) {
  if (op2 == BigInteger::ZERO) {
    throw DividedByZeroException();
  }
  BigInteger t1 = op1.abs(), t2 = op2.abs();
  if (t1 < t2) {
    op1 = BigInteger::ZERO;
    return op1;
  }
  deque<char> temp;
  vector<char>::reverse_iterator iter = t1.digits.rbegin();
  BigInteger temp2(0);
  while (iter != t1.digits.rend()) {
    temp2 = temp2 * BigInteger::TEN + BigInteger((int)(*iter));
    char s = 0;
    while (temp2 >= t2) {
      temp2 = temp2 - t2;
      s = s + 1;
    }
    temp.push_front(s);
    iter++;
  }
  op1.digits.clear();
  op1.digits.insert(op1.digits.end(), temp.begin(), temp.end());
  op1.trim();
  op1.sign = ((op1.sign && op2.sign) || (!op1.sign && !op2.sign));
  return op1;
}
BigInteger operator%=(BigInteger& op1,
                      const BigInteger& op2) throw(DividedByZeroException) {
  return op1 -= ((op1 / op2) * op2);
}
BigInteger operator+(const BigInteger& op1, const BigInteger& op2) {
  BigInteger temp(op1);
  temp += op2;
  return temp;
}
BigInteger operator-(const BigInteger& op1, const BigInteger& op2) {
  BigInteger temp(op1);
  temp -= op2;
  return temp;
}
BigInteger operator*(const BigInteger& op1, const BigInteger& op2) {
  BigInteger temp(op1);
  temp *= op2;
  return temp;
}
BigInteger operator/(const BigInteger& op1,
                     const BigInteger& op2) throw(DividedByZeroException) {
  BigInteger temp(op1);
  temp /= op2;
  return temp;
}
BigInteger operator%(const BigInteger& op1,
                     const BigInteger& op2) throw(DividedByZeroException) {
  BigInteger temp(op1);
  temp %= op2;
  return temp;
}
BigInteger operator-(const BigInteger& op) {
  BigInteger temp = BigInteger(op);
  temp.sign = !temp.sign;
  return temp;
}
BigInteger operator++(BigInteger& op) {
  op += BigInteger::ONE;
  return op;
}
BigInteger operator++(BigInteger& op, int x) {
  BigInteger temp(op);
  ++op;
  return temp;
}
BigInteger operator--(BigInteger& op) {
  op -= BigInteger::ONE;
  return op;
}
BigInteger operator--(BigInteger& op, int x) {
  BigInteger temp(op);
  --op;
  return temp;
}
bool operator<(const BigInteger& op1, const BigInteger& op2) {
  if (op1.sign != op2.sign) {
    return !op1.sign;
  } else {
    if (op1.digits.size() != op2.digits.size())
      return (op1.sign && op1.digits.size() < op2.digits.size()) ||
             (!op1.sign && op1.digits.size() > op2.digits.size());
    vector<char>::const_reverse_iterator iter1, iter2;
    iter1 = op1.digits.rbegin();
    iter2 = op2.digits.rbegin();
    while (iter1 != op1.digits.rend()) {
      if (op1.sign && *iter1 < *iter2) {
        return true;
      }
      if (op1.sign && *iter1 > *iter2) {
        return false;
      }
      if (!op1.sign && *iter1 > *iter2) {
        return true;
      }
      if (!op1.sign && *iter1 < *iter2) {
        return false;
      }
      iter1++;
      iter2++;
    }
    return false;
  }
}
bool operator==(const BigInteger& op1, const BigInteger& op2) {
  if (op1.sign != op2.sign || op1.digits.size() != op2.digits.size()) {
    return false;
  }
  vector<char>::const_iterator iter1, iter2;
  iter1 = op1.digits.begin();
  iter2 = op2.digits.begin();
  while (iter1 != op1.digits.end()) {
    if (*iter1 != *iter2) {
      return false;
    }
    iter1++;
    iter2++;
  }
  return true;
}
bool operator!=(const BigInteger& op1, const BigInteger& op2) {
  return !(op1 == op2);
}
bool operator>=(const BigInteger& op1, const BigInteger& op2) {
  return (op1 > op2) || (op1 == op2);
}
bool operator<=(const BigInteger& op1, const BigInteger& op2) {
  return (op1 < op2) || (op1 == op2);
}
bool operator>(const BigInteger& op1, const BigInteger& op2) {
  return !(op1 <= op2);
}
ostream& operator<<(ostream& stream, const BigInteger& val) {
  if (!val.sign) {
    stream << "-";
  }
  for (vector<char>::const_reverse_iterator iter = val.digits.rbegin();
       iter != val.digits.rend(); iter++) {
    stream << (char)((*iter) + '0');
  }
  return stream;
}
istream& operator>>(istream& stream, BigInteger& val) {
  string str;
  stream >> str;
  val = BigInteger(str);
  return stream;
}
BigInteger n, p, w, d;
BigInteger x, y;
BigInteger exgcd(BigInteger a, BigInteger b) {
  if (b == 0) {
    x = 1, y = 0;
    return a;
  }
  BigInteger q = exgcd(b, a % b);
  BigInteger t = x;
  x = y;
  y = t - (a / b) * y;
  return q;
}
int main() {
  cin >> n >> p >> w >> d;
  BigInteger gcd = exgcd(w, d);
  if (p % gcd != 0) {
    cout << "-1" << endl;
    return 0;
  }
  w /= gcd, d /= gcd, p /= gcd;
  x *= p, y *= p;
  BigInteger num = y / w;
  x += num * d, y -= num * w;
  if (x < 0) x += d, y -= w;
  if (y < 0) x -= d, y += w;
  if (x < 0 || y < 0 || x + y > n) {
    cout << "-1" << endl;
    return 0;
  }
  cout << x << ' ' << y << ' ' << n - x - y << ' ' << endl;
}
