#pragma GCC optimize("O2")
#include "hpmq.h"
#include <bits/stdc++.h>

using namespace std;

#define mp make_pair
#define pb emplace_back
#define rep(i, s, e) for (int i = s; i <= e; ++i)
#define drep(i, s, e) for (int i = s; i >= e; --i)
#define file(a) freopen(#a".in", "r", stdin), freopen(#a".out", "w", stdout)
#define pv(a) cout << #a << " = " << a << endl
#define pa(a, l, r) cout << #a " : "; rep(_, l, r) cout << a[_] << ' '; cout << endl

using ull = unsigned long long;
using pii = pair <int, int>;

const int INF = 0x3f3f3f3f;

const int N = 6e5 + 10;
const int M = 3e4 + 10;

int read() {
  int x = 0, f = 1; char c = getchar();
  for (; c < '0' || c > '9'; c = getchar()) if (c == '-') f = -1;
  for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - 48;
  return x * f;
}

mt19937_64 rng(time(0));
int Rand(int l, int r) {
  return l + rng() % (r - l + 1);
}

struct frac {
  int p, q;
  frac(int _p = 0, int _q = 1) {
    p = _p, q = _q;
    if (q < 0) p = -p, q = -q;
  }
  friend bool operator < (frac a, frac b) {
    return 1ll * a.p * b.q < 1ll * b.p * a.q;
  }
  friend bool operator == (frac a, frac b) {
    return 1ll * a.p * b.q == 1ll * b.p * a.q;
  }
  void print() {
    printf("%d/%d\n", p, q);
  }
} ;

struct vec {
  int x, y;
  void init() {
    x = read(), y = read();
  }
  friend bool operator < (vec a, vec b) {
    return a.x == b.x ? a.y < b.y : a.x < b.x;
  }
  void print() {
    printf("(%d, %d)\n", x, y);
  }
} ;

struct line {
  int a, b, c;
  frac k;
  line(int _a = 0, int _b = 1, int _c = 0) {
    a = _a, b = _b, c = -_c;
    k = frac(-a, b);
  }
  bool chk(vec p) {
    return a * p.x + b * p.y + c < 0;
  }
  bool above(vec p) {
    if (b > 0) return a * p.x + b * p.y + c < 0;
    else return a * p.x + b * p.y + c > 0;
  }
  friend bool operator < (line l1, line l2) {
    if (l1.k == l2.k) return frac(-l1.c, l1.b) < frac(-l2.c, l2.b);
    else return l2.k < l1.k;
  }
} ;

frac inter(line l1, line l2) {
  return frac(l2.c * l1.b - l1.c * l2.b, l1.a * l2.b - l2.a * l1.b);
}

#define ls lson[u]
#define rs rson[u]

int tot, lson[N], rson[N];
vec p[N];
Data dat[N];
Operation laz[N];

void down(int u, Operation o) {
  o.apply(dat[u]);
  o.apply(laz[u]);
}

void pushdown(int u) {
  down(ls, laz[u]);
  down(rs, laz[u]);
  laz[u].clr();
}

void maintain(int u) {
  p[u] = p[ls];
  dat[u].add(dat[ls], dat[rs]);
}

int newnode() {
  return ++ tot;
}

void undo() {
  pushdown(tot);
  lson[tot] = rson[tot] = 0;
  p[tot] = vec();
  dat[tot].clr();
  -- tot;
}

struct O {
  line l;
  Operation o;
} op[N];

int n, m, B, rk[N];
ull pre[N], suf[N], h[N], key[N];

void solve(int l, int r, vector <int> c) {
  int len = r - l + 1, cur = tot;
  auto work = [&]() {
    for (auto it : c) h[it] = 0;
    vector <int> ord;
    rep(i, l, r) ord.pb(i);
    sort(ord.begin(), ord.end(), [&](int i, int j) {
      return op[i].l < op[j].l;
    });
    rep(i, 0, len - 1) {
      key[ord[i]] = rng() % (1ll << 60);
      pre[ord[i]] = i ? pre[ord[i - 1]] : 0;
      if (op[ord[i]].l.b < 0) pre[ord[i]] ^= key[ord[i]];
      rk[ord[i]] = i;
    }
    drep(i, len - 1, 0) {
      suf[ord[i]] = i < len - 1 ? suf[ord[i + 1]] : 0;
      if (op[ord[i]].l.b > 0) suf[ord[i]] ^= key[ord[i]];
    }
    sort(c.begin(), c.end(), [&](int i, int j) {
      return p[i] < p[j];
    });
    vector <pair <frac, pii> > px;
    rep(i, 0, len - 1) rep(j, i + 1, len - 1) if (op[ord[j]].l.k < op[ord[i]].l.k) {
      px.pb(mp(inter(op[ord[i]].l, op[ord[j]].l), mp(ord[i], ord[j])));
    }
    px.pb(mp(frac(INF, 1), mp(0, 0)));
    sort(px.begin(), px.end(), [&](pair <frac, pii> a, pair <frac, pii> b) {
      if (a.first == b.first) {
        if (rk[a.second.first] == rk[b.second.first]) {
          return rk[a.second.second] < rk[b.second.second];
        }
        else return rk[a.second.first] < rk[b.second.first];
      }
      else return a.first < b.first;
    });
    for (int i = 0, j = 0; i < px.size(); ++ i) {
      for (; j < c.size() && p[c[j]].x < px[i].first; ++ j) {
        auto it = partition_point(ord.begin(), ord.end(), [&](int k) {
          return !op[k].l.above(p[c[j]]);
        });
        if (it != ord.end()) h[c[j]] ^= suf[*it];
        if (it != ord.begin()) h[c[j]] ^= pre[*(-- it)];
      }
      int u = px[i].second.first, v = px[i].second.second;
      if (!u && !v) continue;
      assert(rk[u] + 1 == rk[v]);
      swap(ord[rk[u]], ord[rk[v]]);
      swap(rk[u], rk[v]);
      if (op[u].l.b < 0) pre[v] ^= key[u];
      else suf[v] ^= key[u];
      if (op[v].l.b < 0) pre[u] ^= key[v];
      else suf[u] ^= key[v];
    }
    sort(c.begin(), c.end(), [&](int i, int j) {
      return h[i] < h[j];
    });
    vector <int> nc;
    for (int i = 0, j; i < c.size(); i = j + 1) {
      for (j = i; j + 1 < c.size() && h[c[j + 1]] == h[c[i]]; ++ j) ;
      if (i < j) {
        rep(k, i + 1, j) {
          int u = newnode();
          ls = k == i + 1 ? c[i] : u - 1, rs = c[k];
          maintain(u);
        }
        nc.pb(tot);
      }
      else nc.pb(c[i]);
    }
    c = nc;
  } ;
  work();
  if (l == r) {
    bool flag = false;
    for (auto it : c) {
      if (op[l].l.chk(p[it])) {
        dat[it].print();
        down(it, op[l].o);
        flag = true;
        break;
      }
    }
    if (!flag) Data().print();
    while (tot > cur) undo();
    return;
  }
  int mid = (l + r) >> 1;
  solve(l, mid, c);
  solve(mid + 1, r, c);
  while (tot > cur) undo();
}

#undef ls
#undef rs

void solve(const int _n, const int _m, const int *_x, const int *_y, const Data *_d, 
const int *_a, const int *_b, const int *_c, const Operation *_o) {
  n = _n, m = _m, tot = n, B = sqrt(n);
  rep(i, 1, n) p[i].x = _x[i - 1], p[i].y = _y[i - 1], dat[i] = _d[i - 1];
  rep(i, 1, m) op[i].l = line(_a[i - 1], _b[i - 1], _c[i - 1]), op[i].o = _o[i - 1];
  for (int l = 1, r; l <= m; l = r + 1) {
    r = min(l + B - 1, m);
    vector <int> all;
    rep(i, 1, n) all.pb(i);
    solve(l, r, all);
  }
}