#include <bits/stdc++.h>
using namespace std;
long long Set(long long N, long long p) { return N | (1 << p); }
long long reset(long long N, long long p) { return N & ~(1 << p); }
bool check(long long N, int p) {
  long long fuck = 1;
  return (bool)(N & (fuck << p));
}
long long bigmod(long long a, long long b) {
  if (b == 0) return 1;
  long long c = bigmod(a, b / 2);
  if (b & 1) return ((c * c) % 1000000007 * a) % 1000000007;
  return (c * c) % 1000000007;
}
struct Point {
  long long x, y;
};
Point points[50001];
int n, d;
Point p0;
Point nextToTop(stack<Point> &S) {
  Point p = S.top();
  S.pop();
  Point res = S.top();
  S.push(p);
  return res;
}
void swap(Point &p1, Point &p2) {
  Point temp = p1;
  p1 = p2;
  p2 = temp;
}
long long distSq(Point p1, Point p2) {
  return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);
}
int orientation(Point p, Point q, Point r) {
  long long val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
  if (val == 0) return 0;
  return (val > 0) ? 1 : 2;
}
int compare(const void *vp1, const void *vp2) {
  Point *p1 = (Point *)vp1;
  Point *p2 = (Point *)vp2;
  int o = orientation(p0, *p1, *p2);
  if (o == 0) return (distSq(p0, *p2) >= distSq(p0, *p1)) ? -1 : 1;
  return (o == 2) ? -1 : 1;
}
double convexHull(int n) {
  long long ymin = points[0].y, mi = 0;
  for (int i = 1; i < n; i++) {
    long long y = points[i].y;
    if ((y < ymin) || (ymin == y && points[i].x < points[mi].x))
      ymin = points[i].y, mi = i;
  }
  swap(points[0], points[mi]);
  p0 = points[0];
  qsort(&points[1], n - 1, sizeof(Point), compare);
  int m = 1;
  for (int i = 1; i < n; i++) {
    while (i < n - 1 && orientation(p0, points[i], points[i + 1]) == 0) i++;
    points[m] = points[i];
    m++;
  }
  if (m == 1)
    return 2 * acos(-1.0) * d;
  else if (m == 2)
    return 2 * acos(-1.0) * d + 2 * sqrt(distSq(points[0], points[1]));
  stack<Point> S;
  S.push(points[0]);
  S.push(points[1]);
  S.push(points[2]);
  int siz = 3;
  for (int i = 3; i < m; i++) {
    while (orientation(nextToTop(S), S.top(), points[i]) != 2) S.pop(), siz--;
    S.push(points[i]);
    siz++;
  }
  if (siz == 1)
    return 2 * acos(-1.0) * d;
  else if (siz == 2)
    return 2 * acos(-1.0) * d + 2 * sqrt(distSq(points[0], points[1]));
  for (int i = siz - 1; i >= 0; i--) {
    points[i] = S.top();
    S.pop();
  }
  double ans = 0;
  for (int i = 0; i <= siz - 1; i++) {
    int next = (i + 1) % siz, prev = (i - 1) % siz;
    if (prev < 0) prev += siz;
    double one = sqrt(distSq(points[prev], points[next]));
    double two = sqrt(distSq(points[i], points[next]));
    double thr = sqrt(distSq(points[prev], points[i]));
    double ang = (two * two + thr * thr - one * one) / (2 * thr * two);
    if (ang > 1) ang = 1;
    if (ang < -1) ang = -1;
    ang = acos(ang);
    ang = acos(-1.0) - ang;
    ans += ang * d + two / 2 + thr / 2;
  }
  return ans;
}
int main() {
  long long n, m, x, y;
  long long k;
  cin >> n >> m >> k >> x >> y;
  long long mx, mn;
  long long ans;
  if (n == 1) {
    mx = mn = ans = k / m;
    if (k % m != 0) mx++;
    long long r = k % m;
    if (y <= r) ans++;
  } else {
    long long r = k % (2 * (n - 1) * m);
    if (n != 2) {
      mx = (k / (2 * (n - 1) * m)) * 2;
      if (r <= m)
        ;
      else if (r <= m * n)
        mx++;
      else
        mx += 2;
      if ((k / (2 * (n - 1) * m)) == 0) {
        if (r != 0) {
          if (r <= m * n)
            mx = 1;
          else
            mx = 2;
        } else
          mx = 0;
      }
    } else {
      mx = (k / (2 * (n - 1) * m));
      if (r >= 1) mx++;
    }
    mn = (k / (2 * (n - 1) * m));
    if (r <= m * n - 1)
      ;
    else
      mn++;
    if (x != 1 and x != n) {
      ans = (k / (2 * (n - 1) * m)) * 2;
      if (r < (m * (x - 1) + y))
        ;
      else if (r <= m * n)
        ans++;
      else {
        r -= m * n;
        bool flag = 0;
        for (long long bush = n - 1; bush > 0 and r; bush--) {
          for (long long yuki = 1; yuki <= m and r; yuki++) {
            r--;
            if (bush == x and yuki == y) flag = 1;
          }
        }
        if (flag)
          ans += 2;
        else
          ans++;
      }
    } else {
      ans = (k / (2 * (n - 1) * m));
      if (x == 1) {
        if (r < y)
          ;
        else
          ans++;
      } else {
        if (r < (m * (x - 1) + y))
          ;
        else
          ans++;
      }
    }
  }
  cout << mx << " " << mn << " " << ans << endl;
}
