#include <bits/stdc++.h>
using namespace std;
struct Point {
  long long x, y, t;
  Point() : x(), y(), t() {}
  Point(long long _x, long long _y) : x(_x), y(_y), t() {}
  void scan() { scanf("%lld%lld", &x, &y); }
  Point operator-(Point p) { return Point(x - p.x, y - p.y); }
  bool operator<(const Point &p) const {
    if (x == p.x) return y < p.y;
    return x < p.x;
  }
  long long operator%(Point p) { return x * p.x + y * p.y; }
  long long operator*(Point p) { return x * p.y - y * p.x; }
  long long length2() { return *this % *this; }
  bool on_line(Point A, Point B) {
    Point C = *this;
    return (A - C) * (B - C) == 0;
  }
  bool operator==(const Point &p) const { return x == p.x && p.y == y; }
};
Point origin;
bool cmp_by_angle(const Point &A, const Point &B) {
  Point a = A;
  a = a - origin;
  Point b = B;
  b = b - origin;
  long long mul = a * b;
  if (mul == 0) return a.length2() < b.length2();
  return mul > 0;
}
const long long INF = (long long)2e9;
const int N = 200500;
int n, m;
Point points[N];
Point hull[N];
int hull_size;
void build_hull() {
  int ind = min_element(points, points + n) - points;
  swap(points[0], points[ind]);
  origin = points[0];
  sort(points + 1, points + n, cmp_by_angle);
  int ptr = n - 2;
  while (ptr > 0 && points[ptr].on_line(points[0], points[n - 1])) ptr--;
  ptr++;
  reverse(points + ptr, points + n);
  for (int i = 0; i < n; i++) {
    while (hull_size >= 2 &&
           (points[i] - hull[hull_size - 1]) *
                   (hull[hull_size - 2] - hull[hull_size - 1]) <
               0)
      hull_size--;
    hull[hull_size++] = points[i];
  }
}
void solve() {
  scanf("%d%d", &n, &m);
  int tmp1, tmp2;
  scanf("%d%d", &tmp1, &tmp2);
  for (int i = 0; i < n; i++) {
    points[i].scan();
    points[i].t = 1;
  }
  for (int i = 0; i < m; i++) {
    points[n + i].scan();
    points[n + i].t = 2;
  }
  n += m;
  long long max_x = -INF, max_y = -INF;
  for (int i = 0; i < n; i++) {
    max_x = max(max_x, points[i].x);
    max_y = max(max_y, points[i].y);
  }
  points[n++] = Point(-1, -1);
  points[n++] = Point(max_x, -1);
  points[n++] = Point(-1, max_y);
  sort(points, points + n);
  n = unique(points, points + n) - points;
  build_hull();
  for (int i = 0; i < hull_size; i++)
    if (hull[i].t == 1) {
      puts("Max");
      return;
    }
  puts("Min");
}
int main() {
  solve();
  0;
  return 0;
}
