#include <bits/stdc++.h>

using namespace std;

// #define LOCK_GETCHAR
// #define USE_INT_128

#if __cplusplus < 201400
#warning "Please use c++14 or higher."
#define CONSTEXPR_FUNC
#define ENABLE_IF_INT
#else
#define CONSTEXPR_FUNC constexpr
#define ENABLE_IF_INT , enable_if_t<_is_integer<T>, int> = 0
template <class T> constexpr bool _is_integer = numeric_limits<T>::is_integer;
template <> constexpr bool _is_integer<bool> = false;
template <> constexpr bool _is_integer<char> = false;
#ifdef USE_INT_128
template <> constexpr bool _is_integer<__int128> = true;
template <> constexpr bool _is_integer<__uint128_t> = true;
#endif
template <class T ENABLE_IF_INT>
constexpr T INF = numeric_limits<T>::max() >> 1;
#endif

#if !defined(_WIN32) && !defined(LOCK_GETCHAR)
#define getchar getchar_unlocked
#endif

#define il inline
#define mkp make_pair
#define fi first
#define se second
#define For(i, j, k) for (decltype(j - k) i = (j); i <= (k); ++i)     // NOLINT
#define ForDown(i, j, k) for (decltype(j - k) i = (j); i >= (k); --i) // NOLINT
#define pb push_back
#define eb emplace_back
#ifndef ONLINE_JUDGE
#define FileIO(filename)                                                       \
  freopen(filename ".in", "r", stdin);                                         \
  freopen(filename ".out", "w", stdout)
#else
#define FileIO(filename) void(0)
#endif

using ll = long long;
using uint = unsigned int;
using ull = unsigned long long;
using db = double;
using ldb = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#ifdef USE_INT_128
using lll = __int128_t;
using ulll = __uint128_t;
#endif

// clang-format off
template<typename T> constexpr il T sq(const T & x){ return x * x; }
template<typename T> CONSTEXPR_FUNC il void cmin(T & x, const T &y){ x = min(x, y); }
template<typename T> CONSTEXPR_FUNC il void cmax(T & x, const T &y){ x = max(x, y);}
template<typename T> CONSTEXPR_FUNC il T qpow(T x, ull y, T mod){T ans = 1; x %= mod; while (y) { if(y & 1)(ans *= x) %= mod;(x *= x) %= mod; y >>= 1;} return ans;}
template<typename T> CONSTEXPR_FUNC il T qpow(T x, ull y){T ans = 1; while (y) {if(y & 1) ans *= x;x *= x;y >>= 1;} return ans;}
template<typename T ENABLE_IF_INT> il void read(T &x){ x = 0; int f = 1; int c = getchar(); while(!isdigit(c)) {if (c == '-') f = -1;c = getchar();} while(isdigit(c)) {x = x * 10 + c - '0';c = getchar();} x *= f;}
template<typename T, typename ... Args> il void read(T &x, Args &... y){ read(x); read(y...); }
// clang-format on

// File head end

namespace {
constexpr ll MAXN = 2e5 + 5;
int n, q;
bool tp[MAXN];
ll qry_pos[MAXN];
vector<ll> pool;
struct Line {
  ll L, R, k, b;
  ll operator()(int x) const {
    // if (x < L || x > R)
    //   cerr << pool[x - 1] << ' ' << L << ' ' << R << ' ' << k << ' ' << b
    //        << '\n';
    assert(x >= L && x <= R);
    return k * pool[x - 1] + b;
  }
} li[MAXN * 2];
struct Node {
  int l, r, id;
  Node() : l(0), r(0), id(0) {}
} T[MAXN << 3];
#define mid(p) ((T[p].l + T[p].r) >> 1)
#define lc(p) (mid(p) << 1)
#define rc(p) (mid(p) << 1 | 1)
void build(int p, int l, int r) {
  T[p].l = l, T[p].r = r;
  if (l == r)
    return;
  build(lc(p), l, mid(p)), build(rc(p), mid(p) + 1, r);
}
il void f(int p, int u) {
  int l = T[p].l, r = T[p].r, mid = (l + r) >> 1, &v = T[p].id;
  auto f1 = mkp(li[u](mid), u) < mkp(li[v](mid), v);
  if (f1)
    swap(u, v);
  if (mkp(li[u](l), u) < mkp(li[v](l), v))
    f(lc(p), u);
  if (mkp(li[u](r), u) < mkp(li[v](r), v))
    f(rc(p), u);
}
void ins(int p, int id) {
  int l = T[p].l, r = T[p].r, ql = li[id].L, qr = li[id].R;
  if (ql <= l && qr >= r)
    return f(p, id);
  int mid = (l + r) >> 1;
  if (ql <= mid)
    ins(lc(p), id);
  if (qr > mid)
    ins(rc(p), id);
}
ll qry(int p, int pos) {
  if (T[p].l == T[p].r)
    return li[T[p].id](pos);
  ll ans = li[T[p].id](pos);
  if (pos <= mid(p))
    cmin(ans, qry(lc(p), pos));
  else
    cmin(ans, qry(rc(p), pos));
  return ans;
}
il void Main() {
  read(n, q);
  li[0] = {-ll(1e9) - 5, ll(1e9) + 5, 0, ll(1e18)};
  For(i, 1, n) {
    read(li[q + i].L, li[q + i].R, li[q + i].k, li[q + i].b), li[q + i].R--;
    pool.eb(li[q + i].L), pool.eb(li[q + i].R);
  }
  For(i, 1, q) {
    int op;
    read(op), tp[i] = op;
    if (!op) {
      read(li[i].L, li[i].R, li[i].k, li[i].b), li[i].R--;
      pool.eb(li[i].L), pool.eb(li[i].R);
    } else {
      read(qry_pos[i]), pool.eb(qry_pos[i]);
    }
  }
  sort(pool.begin(), pool.end());
  pool.erase(unique(pool.begin(), pool.end()), pool.end());
  build(1, 1, pool.size());
  For(i, 1, n) {
    li[q + i].L =
        lower_bound(pool.begin(), pool.end(), li[q + i].L) - pool.begin() + 1;
    li[q + i].R =
        lower_bound(pool.begin(), pool.end(), li[q + i].R) - pool.begin() + 1;
    // cerr << li[q + i].L << ' ' << li[q + i].R << '\n';
    ins(1, q + i);
  }
  // cerr << "ok\n";
  For(i, 1, q) {
    if (!tp[i]) {
      li[i].L =
          lower_bound(pool.begin(), pool.end(), li[i].L) - pool.begin() + 1;
      li[i].R =
          lower_bound(pool.begin(), pool.end(), li[i].R) - pool.begin() + 1;
      ins(1, i);
    } else {
      qry_pos[i] =
          lower_bound(pool.begin(), pool.end(), qry_pos[i]) - pool.begin() + 1;
      ll ans = qry(1, qry_pos[i]);
      if (ans == ll(1e18))
        puts("NO");
      else
        printf("%lld\n", ans);
    }
  }
}
} // namespace

signed main() { return Main(), 0; }