#include<cstdio>

 #include<vector>

 #include<algorithm>

 #define ls (x<<1)

 #define rs (ls|1)

 #define lson ls,L,mid

 #define rson rs,mid+1,R

 #define rep(i,l,r) for (int i=(l); i<=(r); i++)

 typedef long long ll;

 using namespace std;

 const int N=;

 const ll inf=1000000000000000000ll;

 int n,m,cnt,x,y,c,tim,op,fr,d,id[N],L[N],R[N],X[N],K[N];

 int h[N],nxt[N],pos[N],to[N],st[N<<],ed[N<<],q[N];

 ll a[N],b[N],ans[N];

 vector<int>T[N<<],V[N];

 ll rd(){

     ll x=; bool t=; char ch=getchar();

     while (ch<'' || ch>'') t|=(ch=='-'),ch=getchar();

     while (ch>='' && ch<='') x=x*+ch-'',ch=getchar();

     if (t) return -x; else return x;

 }

 bool cmp0(int x,int y){ return L[x]<L[y]; }

 bool cmp1(int x,int y){ return a[x]>a[y] || (a[x]==a[y] && b[x]>b[y]); }

 bool cmp2(int a,int b){ return X[a]<X[b]; }

 bool Cmp(int x,int y,int z){ return ((b[y]-b[x])*(a[y]-a[z])>=(b[z]-b[y])*(a[x]-a[y])); }

 void add(int u,int v){ to[++cnt]=v; nxt[cnt]=h[u]; h[u]=cnt; }

 void dfs(int x){ L[x]=++tim; for (int i=h[x]; i; i=nxt[i]) dfs(to[i]); R[x]=tim; }

 void build(int x,int L,int R){

     ed[x]=-;

     if (L==R) { pos[L]=x; return; }

     int mid=(L+R)>>; build(lson); build(rson);

 }

 void ins(int x,int L,int R,int l,int r,int k){

     if (L==l && r==R){

         int &j=ed[x];

         for (; st[x]<j && Cmp(T[x][j-],T[x][j],k); j--,T[x].pop_back());

         j++; T[x].push_back(k);

         return;

     }

     int mid=(L+R)>>;

     if (r<=mid) ins(lson,l,r,k);

     else if (l>mid) ins(rson,l,r,k);

         else ins(lson,l,mid,k),ins(rson,mid+,r,k);

 }

 ll que(int k,int x){

     ll ans=inf;

     for (int i=pos[k]; i; i>>=){

         int &j=st[i];

         for (; j<ed[i] && (a[T[i][j]]-a[T[i][j+]])*x>=b[T[i][j+]]-b[T[i][j]]; j++);

         if (j<=ed[i]) ans=min(ans,a[T[i][j]]*x+b[T[i][j]]);

     }

     return ans;

 }

 int main(){

     freopen("travel.in","r",stdin);

     freopen("travel.out","w",stdout);

     n=rd(); m=rd(); b[]=rd(); id[]=;

     rep(i,,n){

         op=rd(); fr=rd()+; d=rd()+; add(fr,i);

         if (op) V[d].push_back(i);

         else id[d]=i,x=rd(),rd(),rd(),c=rd(),a[d]=-2ll*x,b[d]=1ll*x*x+c;

     }

     dfs(); build(,,n);

     rep(i,,n) q[i]=i; sort(q+,q+n+,cmp1);

     rep(l,,n) if (id[q[l]]){

         int i=q[l];

         sort(V[i].begin(),V[i].end(),cmp0); int k=L[id[i]];

         for (vector<int>::iterator it=V[i].begin(); it!=V[i].end(); k=R[*it]+,it++)

             if (k<L[*it]) ins(,,n,k,L[*it]-,i);

         if (k<=R[id[i]]) ins(,,n,k,R[id[i]],i);

     }

     rep(i,,m) q[i]=i,x=rd(),y=rd(),K[i]=L[x+],X[i]=y;

     sort(q+,q+m+,cmp2);

     rep(i,,m) ans[q[i]]=que(K[q[i]],X[q[i]])+1ll*X[q[i]]*X[q[i]];

     rep(i,,m) printf("%lld\n",ans[i]);

     return ;

 }