#include <cstdio>

#include <cstring>

#include <algorithm>

char xB[(<<)+],*xS,*xT;

#define gtc (xS==xT&&(xT=(xS=xB)+fread(xB,1,1<<15,stdin),xS==xT)?0:*xS++)

inline void read(int &x){

  register char ch=gtc;

  for(x=;ch<''||ch>'';ch=gtc);

  for(;ch>=''&&ch<='';x=(x<<)+(x<<)+ch-'',ch=gtc);

}

#define mid ((l+r)>>1)

#define newnode (node+(sz++))

#define renode (stack[top--])

#define diymax(a,b) ((a)>(b)?(a):(b))

#define diymin(a,b) ((a)<(b)?(a):(b))

const int N=;

const int oo=;

const int Inf=0x3f3f3f3f;

const double alpha=0.72;

struct Point{

  int x[],w;

}list[N];

int len,cmp;

inline bool comp(Point a,Point b){

  return a.x[cmp]<b.x[cmp];

}

struct Segment_Tree{

  Segment_Tree *ch[];

  int size;

  inline void* operator new (size_t);

}*k1[N*],*k2[N*],*C,*mempool,*null,*head;

int len1,len2;

int t1[*N],t2[*N],cnt1,cnt2;

inline void* Segment_Tree:: operator new (size_t){

  if(C==mempool){

    C=new Segment_Tree[(<<)+];

    mempool=C+(<<)+;

  }

  return C++;

}

inline void Init_Segment_Tree(){

  null=new Segment_Tree;

  null->ch[]=null->ch[]=null;

  null->size=;

}

inline void get(Segment_Tree *p){

  p->ch[]=head,head=p;

}

inline Segment_Tree *New(){

  Segment_Tree *ret;

  if(head!=NULL)

    ret=head,head=head->ch[];

  else

    ret=new Segment_Tree;

  ret->ch[]=ret->ch[]=null;

  ret->size=;

  return ret;

}

inline void bang(Segment_Tree *p){

  if(p==null)return;

  bang(p->ch[]),bang(p->ch[]);

  get(p);

}

inline void insert(Segment_Tree *&p,int l,int r,int key){

  if(p==null)p=New();

  ++p->size;

  if(l==r)return;

  if(key<=mid)insert(p->ch[],l,mid,key);

  else insert(p->ch[],mid+,r,key);

}

inline int query(int *x,int z,int y,int jud){

  if(x[z]>jud)return z-;

  int l=z,r=y,ret=y;

  while(l<=r){

    if(x[mid]<=jud)

      ret=mid,l=mid+;

    else

      r=mid-;

  }

  return ret;

}

inline int query(int l,int r,int a,int b,int c,int d,int k){

  if(l==r)return l;

  int sum=,i,mid1=query(t1,a,b,mid),mid2=query(t2,c,d,mid);

  for(i=;i<len1;++i)sum+=k1[i]->ch[]->size;

  for(i=;i<len2;++i)sum-=k2[i]->ch[]->size;

  sum+=b-mid1,sum-=d-mid2;

  if(sum>=k){

    for(i=;i<len1;++i)k1[i]=k1[i]->ch[];

    for(i=;i<len2;++i)k2[i]=k2[i]->ch[];

    return query(mid+,r,mid1+,b,mid2+,d,k);

  }else{

    for(i=;i<len1;++i)k1[i]=k1[i]->ch[];

    for(i=;i<len2;++i)k2[i]=k2[i]->ch[];

    return query(l,mid,a,mid1,c,mid2,k-sum);

  }

}

struct ScapeGoat_Tree{

  ScapeGoat_Tree *ch[];

  Segment_Tree *root;

  int max[],min[],size;

  Point poi;

  inline void update(int *x){

    max[]=diymax(max[],x[]);

    max[]=diymax(max[],x[]);

    min[]=diymin(min[],x[]);

    min[]=diymin(min[],x[]);

  }

  inline void pushup(){

    max[]=diymax(max[],ch[]->max[]);

    max[]=diymax(max[],ch[]->max[]);

    min[]=diymin(min[],ch[]->min[]);

    min[]=diymin(min[],ch[]->min[]);

    max[]=diymax(max[],ch[]->max[]);

    max[]=diymax(max[],ch[]->max[]);

    min[]=diymin(min[],ch[]->min[]);

    min[]=diymin(min[],ch[]->min[]);

    size=ch[]->size+ch[]->size+;

  }

  inline bool judge(int *x){

    return x[]>=poi.x[]&&x[]>=poi.x[];

  }

  inline bool judge_max(int *x){

    return x[]>=max[]&&x[]>=max[];

  }

  inline bool judge_min(int *x){

    return x[]>=min[]&&x[]>=min[];

  }

  inline bool isbad(){

    return size*alpha+<ch[]->size||size*alpha+<ch[]->size;

  }

}*root,*Null,node[N],*stack[N];

int sz,top;

inline void New(ScapeGoat_Tree *p,Point poi){

  p->size=,p->poi=poi;

  p->root=null;

  p->max[]=p->min[]=poi.x[];

  p->max[]=p->min[]=poi.x[];

  p->ch[]=p->ch[]=Null;

  insert(p->root,,oo,poi.w);

}

inline void Init_ScapeGoat_Tree(){

  Null=newnode;

  Null->ch[]=Null->ch[]=Null;

  Null->root=null;

  Null->max[]=Null->max[]=-Inf;

  Null->min[]=Null->min[]=Inf;

  Null->size=;

  root=Null;

}

inline void travel(ScapeGoat_Tree *p){

  if(p==Null)return;

  travel(p->ch[]),travel(p->ch[]);

  list[++len]=p->poi,stack[++top]=p,bang(p->root);

}

inline void build(ScapeGoat_Tree *&p,int l,int r,int id){

  if(l>r)return void(p=Null);

  cmp=id,std::nth_element(list+l,list+mid,list+r+,comp);

  New(p=renode,list[mid]);

  for(int i=l;i<=r;++i)

    if(i!=mid)insert(p->root,,oo,list[i].w);

  build(p->ch[],l,mid-,id^);

  build(p->ch[],mid+,r,id^);

  p->pushup();

}

inline void rebuild(ScapeGoat_Tree *&p,int id){

  len=,top=,travel(p),build(p,,len,id);

}

inline void insert(ScapeGoat_Tree *&p,Point poi,int id,ScapeGoat_Tree *&ret1,int &ret2){

  if(p==Null)return void(New(p=newnode,poi));

  p->update(poi.x),insert(p->root,,oo,poi.w),++p->size;

  insert(p->ch[poi.x[id]>p->poi.x[id]],poi,id^,ret1,ret2);

  if(p->isbad())ret1=p,ret2=id;

}

inline void Insert(Point poi){

  ScapeGoat_Tree *p=Null;int id=;

  insert(root,poi,,p,id);

  if(p!=Null)rebuild(p,id);

}

inline void dfs(ScapeGoat_Tree *p,int *x,Segment_Tree **k,int &t,int *y,int &cc){

  if(p==Null)return;

  if(p->judge_max(x))return void(k[t++]=p->root);

  if(!p->judge_min(x))return;

  if(p->judge(x))y[++cc]=p->poi.w;

  dfs(p->ch[],x,k,t,y,cc),dfs(p->ch[],x,k,t,y,cc);

}

int main(){

  Init_Segment_Tree();

  Init_ScapeGoat_Tree();

  int T,x,y,a,b,k,f[],ans=,opt,cnt,i,clc=;

  Point temp;

  read(x),read(T);

  while(T--){

    read(opt);

    if(opt==){

      read(x),read(y),read(a);

      x^=ans,y^=ans,a^=ans;

      temp.x[]=x,temp.x[]=y,temp.w=a;

      Insert(temp);

    }else{

      read(x),read(y),read(a),read(b),read(k);

      x^=ans,y^=ans,a^=ans,b^=ans,k^=ans;

      cnt=len1=len2=cnt1=cnt2=;

      f[]=x-,f[]=y-,dfs(root,f,k1,len1,t1,cnt1);

      f[]=a,f[]=y-,dfs(root,f,k2,len2,t2,cnt2);

      f[]=x-,f[]=b,dfs(root,f,k2,len2,t2,cnt2);

      f[]=a,f[]=b,dfs(root,f,k1,len1,t1,cnt1);

      cnt=cnt1-cnt2;

      for(i=;i<len1;++i)cnt+=k1[i]->size;

      for(i=;i<len2;++i)cnt-=k2[i]->size;

      if(cnt<k)

        puts("NAIVE!ORZzyz."),ans=;

      else{

        std::sort(t1+,t1+cnt1+);

        std::sort(t2+,t2+cnt2+);

        ans=query(,oo,,cnt1,,cnt2,k);

        printf("%d\n",ans);

      }

    }

  }

  return ;

}