#include <bits/stdc++.h>
using namespace std;

#define NDEBUG
#include <cassert>


typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> ii;
typedef pair<ll,ll> llll;
typedef pair<double,double> dd;

typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<ii> vii;
typedef vector<vector<ii>> vvii;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<double> vd;

#define pb  push_back
#define eb  emplace_back
#define rep(var,n)  for(int var=0;var<(n);++var)
#define rep1(var,n)  for(int var=1;var<=(n);++var)
#define repC2(vari,varj,n)  for(int vari=0;vari<(n)-1;++vari)for(int varj=vari+1;varj<(n);++varj)
#define repC3(vari,varj,vark,n)  for(int vari=0;vari<(n)-2;++vari)for(int varj=vari+1;varj<(n)-1;++varj)for(int vark=varj+1;vark<(n);++vark)
#define ALL(c)  (c).begin(),(c).end()
#define RALL(c)  (c).rbegin(),(c).rend()
#define whole(f, x, ...)                                     \
    ([&](decltype((x)) whole) {                              \
        return (f)(begin(whole), end(whole), ##__VA_ARGS__); \
    })(x)
#define tr(i,c)  for(auto i=(c).begin(); i!=(c).end(); ++i)
#define found(s,e)  ((s).find(e)!=(s).end())
#define mset(arr,val)  memset(arr,val,sizeof(arr))
#define mid(x,y) ((x)+((y)-(x))/2)
#define IN(x,a,b) ((a)<=(x)&&(x)<=(b))
#define IN_(x,a,b) ((a)<=(x)&&(x)<(b))
#define tors(a) sort(ALL(a), greater<decltype(a[0])>())
#define nC2(n) ((ll)(n)*((n)-1)/2)

#define clamp(v,lo,hi) min(max(v,lo),hi)
#define ABS(x) max((x),-(x))
#define PQ(T) priority_queue<T,vector<T>,greater<T>>
#define CLEAR(a) remove_reference_t<decltype(a)>().swap(a)
template <typename T>
vector<T> vec(size_t len, T elem) { return vector<T>(len, elem); }

template<typename T1, typename T2> inline void amin(T1 & a, T2 const & b) { if (a>b) a=b; }
template<typename T1, typename T2> inline void amax(T1 & a, T2 const & b) { if (a<b) a=b; }

template <typename T>
void erase_one(multiset<T>& ms, T val) {
    auto iter = ms.find(val);
    if (iter != ms.end()) ms.erase(iter);
}

inline ll square(ll x) { return x * x; }
inline ll gcd(ll a, ll b) { while(a) swap(a, b%=a); return b; }
inline ll lcm(ll a, ll b) { return a/gcd(a,b)*b; }
template <typename T>
inline T mod(T a, T b) { return ((a % b) + b) % b; }


#define is_digit(c) ('0'<=(c)&&(c)<='9')
#define is_whitespace(c) ((c)==' '||(c)=='\n'||(c)=='\r'||(c)=='\t'||(c)==EOF)
void reader(int& x){
  x=0;
  bool neg=false; for(;;){ int k=getchar(); if(k=='-'){ neg=true; break; } if (is_digit(k)){ x=k-'0'; break;} }
  for(;;){ int k=getchar(); if (!is_digit(k)) break; x=x*10+k-'0'; }
  if(neg) x=-x; }
void reader(long long& x){
  x=0;
  bool neg=false; for(;;){ int k=getchar(); if(k=='-'){ neg=true; break; } if (is_digit(k)){ x=k-'0'; break; } }
  for(;;){ int k=getchar(); if (!is_digit(k)) break; x=x*10+k-'0'; }
  if(neg) x=-x; }
void reader(unsigned long long& x){
  x=0;
  for(;;){ int k=getchar(); if (is_digit(k)){ x=(unsigned long long)(k-'0'); break; } }
  for(;;){ int k=getchar(); if (!is_digit(k)) break; x=x*10+k-'0'; } }
int reader(char s[]){
  int c,i=0;
  for(;;){ c=getchar(); if (!is_whitespace(c)) break; } s[i++]=c;
  for(;;){ c=getchar(); if (is_whitespace(c)) break; s[i++]=c; }
  s[i]='\0'; return i; }
int reader(string& s){
  int c;
  for(;;){ c=getchar(); if (!is_whitespace(c)) break; } s.push_back(c);
  for(;;){ c=getchar(); if (is_whitespace(c)) break; s.push_back(c); }
  return s.size(); }
void reader(char& c){
  for(;;){ c=getchar(); if (!is_whitespace(c)) break; } }

void writer(int x, char c=0){
  int s=0; bool neg=false; char f[10]; if(x<0) neg=true,x=-x; if(x==0) f[s++]='0'; else while(x) f[s++]='0'+x%10,x/=10;
  if(neg) putchar('-'); while(s--) putchar(f[s]); if(c) putchar(c); }
void writer(long long x, char c=0){
  int s=0; bool neg=false; char f[20]; if(x<0) neg=true,x=-x; if(x==0) f[s++]='0'; else while(x) f[s++]='0'+x%10,x/=10;
  if(neg) putchar('-'); while(s--) putchar(f[s]); if(c) putchar(c); }
void writer(unsigned long long x, char c=0){
  int s=0; char f[20]; if(x==0) f[s++]='0'; else while(x) f[s++]='0'+x%10,x/=10;
  while(s--) putchar(f[s]); if(c) putchar(c); }
void writer(const string& x, char c=0){
  for(int i=0;i<x.size();++i) putchar(x[i]); if(c) putchar(c); }
void writer(const char x[], char c=0){
  for(int i=0;x[i]!='\0';++i) putchar(x[i]); if(c) putchar(c); }

template <class T,class S> void reader(T& x, S& y){ reader(x); reader(y); }
template <class T,class S,class U> void reader(T& x, S& y, U& z){ reader(x); reader(y); reader(z); }
template <class T,class S,class U,class V> void reader(T& x, S& y, U& z, V& w){ reader(x); reader(y); reader(z); reader(w); }
template <class T> vector<T> readerArray(int n){
  vector<T> ret(n); for(int i=0;i<n;++i) reader(ret[i]); return ret; }
template <class T> vector<vector<T>> readerMatrix(int n,int m=0){
  if (m==0) m = n; vector<vector<T>> ret(n); for(int i=0;i<n;++i) ret[i] = readerArray<T>(m); return ret; }

template <class T> void writerLn(T x){ writer(x,'\n'); }
template <class T,class S> void writerLn(T x, S y){ writer(x,' '); writer(y,'\n'); }
template <class T,class S,class U> void writerLn(T x, S y, U z){ writer(x,' '); writer(y,' '); writer(z,'\n'); }
template <class T,class S,class U,class V> void writerLn(T x, S y, U z, V v){ writer(x,' '); writer(y,' '); writer(z,' '); writer(v,'\n'); }
template <class T> void writerArrayLn(T x[], int n){
  if(n==0){ putchar('\n'); return; }
  for(int i=0;i<n-1;++i) writer(x[i],' '); writer(x[n-1],'\n'); }
template <class T> void writerArrayLn(vector<T>& x){ writerArrayLn(x.data(),(int)x.size()); }
template <class T> void writerArrayLnV(T x[], int n){ for(int i=0;i<n;++i) writerLn(x[i]); }
template <class T> void writerArrayLnV(vector<T>& x){ for(T xi: x) writerLn(xi); }
template <class T> void writerMatrix(vector<vector<T>>& x){
  int n = x.size(); if (n == 0) return;
  int m = x[0].size(); for (int i=0; i<n; ++i) writerArrayLn(x[i]); }

void readerEdges(size_t M,vector<int>& a,vector<int>& b,bool decrement=true){
  a.resize(M); b.resize(M);
  for(int i=0;i<M;++i){ reader(a[i]); reader(b[i]); if(decrement){ --a[i]; --b[i]; } } }
template <class W> void readerEdges(size_t M,vector<int>& a,vector<int>& b,vector<W>& c,bool decrement=true){
  a.resize(M); b.resize(M); c.resize(M);
  for(int i=0;i<M;++i){ reader(a[i]); reader(b[i]); reader(c[i]); if(decrement){ --a[i]; --b[i]; } } }
template <class S,class T> void readerEdges(size_t M,vector<int>& a,vector<int>& b,vector<S>& c,vector<T>& d,bool decrement=true){
  a.resize(M); b.resize(M); c.resize(M); d.resize(M);
  for(int i=0;i<M;++i){ reader(a[i]); reader(b[i]); reader(c[i]); reader(d[i]); if(decrement){ --a[i]; --b[i]; } } }

vector<vector<int>> make_nxt(int N, int M, vector<int>& a, vector<int>& b){
  vector<vector<int>> nxt(N);
  for(int i=0;i<M;++i){ nxt[a[i]].push_back(b[i]); nxt[b[i]].push_back(a[i]); }
  return nxt; }
template <class T> vector<vector<pair<int,T>>> make_nxt(int N, int M, vector<int>& a, vector<int>& b, vector<T>& c){
  vector<vector<pair<int,T>>> nxt(N);
  for(int i=0;i<M;++i){ nxt[a[i]].emplace_back(b[i],c[i]); nxt[b[i]].emplace_back(a[i],c[i]); }
  return nxt; }

template <typename T>
struct SparseSegmentTree {
    int depth, N;

    static const T ident = numeric_limits<T>::min();
    static inline T merge(T a, T b) { return max(a, b); }

    struct node {
        int depth;
        T val;
        node *left, *right;
        node(int depth) : depth(depth), val(ident), left(nullptr), right(nullptr) {}
        ~node() {
            if (left) delete(left);
            if (right) delete(right);
        }
        void dump() {
            if (left) left->dump();
            if (right) right->dump();
        }
        T update(int ix, T newval) {
            if (depth == 0) {
                assert(ix == 0);
                return this->val = newval;
            } else {
                T leftval = ident, rightval = ident;
                int mask = 1 << (depth - 1);
                if (ix & mask) {
                    if (!right) right = new node(depth - 1);
                    rightval = right->update(ix & ~mask, newval);
                    leftval = left ? left->val : ident;
                } else {
                    if (!left) left = new node(depth - 1);
                    leftval = left->update(ix & ~mask, newval);
                    rightval = right ? right->val : ident;
                }
                return this->val = merge(leftval, rightval);
            }
        }
        T get(int ix) {
            if (depth == 0) {
                return this->val;
            } else {
                int mask = 1 << (depth - 1);
                if (ix & mask) {
                    return right ? right->get(ix & ~mask) : ident;
                } else {
                    return left ? left->get(ix & ~mask) : ident;
                }
            }
        }
        T query(int a, int b, int l, int r) {
            if (r <= a || b <= l) return ident;

            if (a <= l && r <= b) {
                return val;
            } else {
                T leftval = left ? left->query(a, b, l, (l + r) / 2) : ident;
                T rightval = right ? right->query(a, b, (l + r) / 2, r) : ident;
                return merge(leftval, rightval);
            }
        }
    } *root;

    SparseSegmentTree() : depth(0), N(0) {}
    SparseSegmentTree(int size) { init(size); }

    void init(int size) {
        if (size) {
            N = 1; depth = 0;
            while (N < size) { ++depth; N *= 2; }
        } else {
            N = 0; depth = 0;
        }
        this->root = new node(depth);
    }
    void dump() { root->dump(); }

    void update(int ix, T val) {
        root->update(ix, val);
    }

    T query(int lo, int hi) {
        return root->query(lo, hi, 0, N);
    }
};


template <typename T>
void sort_uniq_max(vector<pair<int,T>>& ar) {
    if (ar.empty()) return;

    sort(ALL(ar));
    int L = ar.size(), i = 0;
    for (int j=1; j<ar.size(); ++j){
        if (ar[i].first == ar[j].first) {
            amax(ar[i].second, ar[j].second);
        } else {
            ++i;
            if (i < j) ar[i] = ar[j];
        }
    }
    ar.resize(i+1);
}

template <typename T>
struct SparseSegmentTree2D {
    int xsize, ysize, H, W;
    vector<SparseSegmentTree<T>*> segs;

    static const T ident = numeric_limits<T>::min();
    static inline T merge(T a, T b) { return max(a, b); }

    SparseSegmentTree2D(int xsize, int ysize) : xsize(xsize), ysize(ysize) {
        W = 1; while (W < xsize) W *= 2;
        segs.assign(2 * W - 1, nullptr);
    }
    ~SparseSegmentTree2D() {
        rep(i, 2*W-1) {
            if (segs[i]) delete(segs[i]);
        }
    }

    void update(int x, int y, T newval){
        int k = x + (W-1);
        while (k >= 0) {
            if (!segs[k]) segs[k] = new SparseSegmentTree<T>(ysize);
            segs[k]->update(y, newval);
            if (k == 0) break;
            k = (k - 1)/2;
        }
    }
    T query(int xlo, int xhi, int ylo, int yhi, int k, int l, int r){
        if (r <= xlo || xhi <= l) return ident;

        if (xlo <= l && r <= xhi) {
            return segs[k] ? segs[k]->query(ylo, yhi) : ident;
        } else {
            return merge(
                query(xlo,xhi, ylo,yhi, 2*k+1, l, (l+r)/2),
                query(xlo,xhi, ylo,yhi, 2*k+2, (l+r)/2, r)
            );
        }
    }

    T query(int xlo, int xhi, int ylo, int yhi){
        return query(xlo, xhi, ylo, yhi, 0, 0, W);
    }
};

inline ll calc_area(vi& triangle) {
    ll x1 = triangle[2] - triangle[0];
    ll y1 = triangle[3] - triangle[1];
    ll x2 = triangle[4] - triangle[0];
    ll y2 = triangle[5] - triangle[1];
    return ABS(x1 * y2 - x2 * y1);
}


void solve(int N, int Q, vvi& triangles, vvi& queries) {
    set<int> xs;
    set<ll> ys;
    vll area(N, 0);
    using P = tuple<int, int, ll>;
    queue<P> triangles_in_queries;
    rep(i, N) {
        for (int j = 0; j < 6; j += 2) {
            xs.insert(triangles[i][j]);
        }
        area[i] = calc_area(triangles[i]);
        ys.insert(area[i]);
    }
    rep(i, Q) {
        int L = queries[i].size();
        if (L == 6) {
            int xmin = INT_MAX, xmax = INT_MIN;
            for (int j = 0; j < 6; j += 2) {
                int x = queries[i][j];
                xs.insert(x);
                amin(xmin, x);
                amax(xmax, x);
            }
            ll q_area = calc_area(queries[i]);
            triangles_in_queries.emplace(xmin, xmax, q_area);
            ys.insert(q_area);

            CLEAR(queries[i]);
        } else {
            xs.insert(queries[i][0]);
            xs.insert(queries[i][1]);
        }
    }
    xs.insert(INT_MIN);
    xs.insert(INT_MAX);
    ys.insert(LLONG_MIN);
    ys.insert(LLONG_MAX);

    map<int, int> zx;
    int zxid = 0;
    for (int x : xs) zx[x] = zxid++;

    CLEAR(xs);

    map<ll, int> zy;
    int zyid = 0;
    vll zyR; zyR.reserve(ys.size());
    for (ll y : ys) {
        zy[y] = zyid++;
        zyR.pb(y);
    }

    CLEAR(ys);


    SparseSegmentTree2D<int> seg(zxid, zxid);

    rep(i, N) {
        int xmin = INT_MAX, xmax = INT_MIN;
        for (int j = 0; j < 6; j += 2) {
            int x = zx[triangles[i][j]];
            amin(xmin, x);
            amax(xmax, x);
        }
        seg.update(xmin, xmax, zy[area[i]]);
    }

    CLEAR(triangles);
    CLEAR(area);

    rep(i, Q) {
        int L = queries[i].size();
        int xmin = INT_MAX, xmax = INT_MIN;
        if (L == 0) {
            auto [xmin, xmax, q_area] = triangles_in_queries.front(); triangles_in_queries.pop();
            seg.update(zx[xmin], zx[xmax], zy[q_area]);
        } else {
            int l = zx[queries[i][0]], r = zx[queries[i][1]];
            int res = seg.query(l, r, l, r+1);
            ll resR = (res >= 0) ? zyR[res] : LLONG_MIN;
            if (resR < 0) resR = -1;
            printf("%lld\n", resR);
        }
    }
}

int main() {
    int N, Q;
    reader(N, Q);
    vvi triangles(N, vi(6));
    rep(i, N) { triangles[i] = readerArray<int>(6); }
    vvi queries(Q);
    rep(i, Q) {
        int op;
        reader(op);
        if (op == 1) {
            queries[i] = readerArray<int>(6);
        } else {
            queries[i] = readerArray<int>(2);
        }
    }
    solve(N, Q, triangles, queries);
    return 0;
}