//prewritten code: https://github.com/antma/algo
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.traits;
import std.numeric;

class InputReader {
  private:
  ubyte[] p;
  ubyte[] buffer;
  size_t cur;
  public:
  this () {
    buffer = uninitializedArray!(ubyte[])(16<<20);
    p = stdin.rawRead (buffer);
  }
  final ubyte skipByte (ubyte lo) {
    while (true) {
      auto a = p[cur .. $];
      auto r = a.find! (c => c >= lo);
      if (!r.empty) {
        cur += a.length - r.length;
        return p[cur++];
      }
      p = stdin.rawRead (buffer);
      cur = 0;
      if (p.empty) return 0;
    }
  }
  final ubyte nextByte () {
    if (cur < p.length) {
       return p[cur++];
    }
    p = stdin.rawRead (buffer);
    if (p.empty) return 0;
    cur = 1;
    return p[0];
  }

  template next(T) if (isSigned!T) {
    final T next ()  {
      T res;
      ubyte b = skipByte (45);
      if (b == 45) {
        while (true) {
          b = nextByte ();
          if (b < 48 || b >= 58) {
            return res;
          }
          res = res * 10 - (b - 48);
        }
      } else {
        res = b - 48;
        while (true) {
          b = nextByte ();
          if (b < 48 || b >= 58) {
            return res;
          }
          res = res * 10 + (b - 48);
        }
      }
    }
  }
  template next(T) if (isUnsigned!T) {
    final T next () {
      T res = skipByte (48) - 48;
      while (true) {
        ubyte b = nextByte ();
        if (b < 48 || b >= 58) {
          break;
        }
        res = res * 10 + (b - 48);
      }
      return res;
    }
  }
}

int dist (int x, int k) {
  x = (x - 1) % k;
  return min (x, k - x);
}

void main() {
  auto r = new InputReader;
  immutable n = r.next!uint;
  immutable k = r.next!uint;
  immutable a = r.next!uint;
  immutable b = r.next!uint;
  long rmin = long.max, rmax = long.min;
  ulong nk = n.to!ulong * k;
  foreach (s; 1 .. k + 1) {
    if (dist (s, k) != a) {
      continue;
    }
    debug stderr.writeln ("s = ", s);
    foreach (l; 1 .. k + 1) {
      immutable sl = l + s;
      if (dist (sl, k) != b) {
        continue;
      }
      debug stderr.writeln ("l = ", l);
      ulong m = l;
      while (m <= nk) {
        long z = nk / gcd (nk, m);
        rmin = min (rmin, z);
        rmax = max (rmax, z);
        m += k;
      }
    }
  }
  writeln (rmin, ' ', rmax);
}

