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

using ll=long long;

#define MAXN 1000005

int n,m,q,l,r;
int a[MAXN],b[MAXN];
ll ql[MAXN],qr[MAXN];
ll ca[MAXN],cb[MAXN]; ll ha,hb;
ll mod=998244353,bas,b2;
ll bp[MAXN];
int rm[MAXN];
bool ans[MAXN];

ll fpow(ll a,ll b,ll p){
    ll res=1; for(;b;b>>=1,a*=a,a%=p) if(b&1) res*=a,res%=p;
    return res;
}
ll fpow(ll a,ll b){return fpow(a,b,mod);}

void add(int p){
    for(int i=3*p-2;i<=3*p;i++){
        ha+=mod-fpow(b2,ca[a[i]]);
        ca[a[i]]+=bp[p]; ca[a[i]]%=mod;
        ha+=fpow(b2,ca[a[i]]);
        hb+=mod-fpow(b2,cb[b[i]]);
        cb[b[i]]+=bp[p]; cb[b[i]]%=mod;
        hb+=fpow(b2,cb[b[i]]);
    }
    ha%=mod; hb%=mod;
    return;
}
void del(int p){
    for(int i=3*p-2;i<=3*p;i++){
        ha+=mod-fpow(b2,ca[a[i]]);
        ca[a[i]]+=mod-bp[p]; ca[a[i]]%=mod;
        ha+=fpow(b2,ca[a[i]]);
        hb+=mod-fpow(b2,cb[b[i]]);
        cb[b[i]]+=mod-bp[p]; cb[b[i]]%=mod;
        hb+=fpow(b2,cb[b[i]]);
    }
    ha%=mod; hb%=mod;
    return;    
}

void run(){
    bp[0]=1;
    for(int i=1;i<=n;i++) bp[i]=(bp[i-1]*bas)%mod;

    l=1,r=0;
    for(;l<=n;l++){
        while(r<=n-1){
            if(ha!=hb){
                break;
            }
            add(++r);
        }
        rm[l]=r-(ha!=hb);
        del(l);
    }

    return;
}

#define ONLINE_JUDGE
namespace LightIO
{
    char piBuf[1 << 21];
    int iRead = 0, iEnd = 0;
    char poBuf[1 << 21];
    int poEnd = 0;
    char ptBuf[30];
    int ptEnd = 0;
    const char lendl = '\n';

    inline int getc()
    {
#ifdef ONLINE_JUDGE
        if (iRead == iEnd)
        {
            iRead = 0;
            iEnd = fread(piBuf, 1, 1 << 21, stdin);
            if (!iEnd)
                return EOF;
        }
        return piBuf[iRead++];
#else
        return getchar();
#endif
    }

    inline void flush()
    {
        fwrite(poBuf, 1, poEnd, stdout);
        poEnd = 0;
    }

    inline void putc(char c)
    {
        if (poEnd >> 20)
            flush();
        poBuf[poEnd++] = c;
    }

    class lcin_base
    {
        friend lcin_base operator>>(const lcin_base &fcb, int &x)
        {
            x = 0;
            int f = 0;
            char ch = getc();
            while (ch < '0' || ch > '9')
            {
                if (ch == '-')
                    f = 1;
                ch = getc();
            }
            while (ch >= '0' && ch <= '9')
            {
                x = (x << 1) + (x << 3) + (ch ^ 48);
                ch = getc();
            }
            if (f)
                x = -x;
            return fcb;
        }
        friend lcin_base operator>>(const lcin_base &fcb, char &x)
        {
            x = getc();
            return fcb;
        }
    } lcin;

    class lcout_base
    {
        friend lcout_base operator<<(const lcout_base &fcb, int x)
        {
            ptEnd = 0;
            if (x < 0)
                putc('-'), x = -x;
            if (x == 0)
                putc('0');
            while (x)
            {
                ptBuf[ptEnd++] = (x % 10) ^ 48;
                x /= 10;
            }
            while (--ptEnd >= 0)
                putc(ptBuf[ptEnd]);
            return fcb;
        }
        friend lcout_base operator<<(const lcout_base &fcb, char x)
        {
            putc(x);
            return fcb;
        }
        friend lcout_base operator<<(const lcout_base &fcb, string s)
        {
            for (int i = 0; i < s.length(); i++)
                putc(s[i]);
            return fcb;
        }
    } lcout;
};
using LightIO::lcin;
using LightIO::lcout;
using LightIO::lendl;
using LightIO::flush;

signed main(){
    srand(time(0));

    lcin>>n>>m>>q;
    for(int i=1;i<=3*n;i++) lcin>>a[i];
    for(int j=1;j<=3*n;j++) lcin>>b[j];
    for(int i=1;i<=q;i++){
        lcin>>ql[i]>>qr[i];
    }
    bas=105,b2=19;
    run();
    for(int i=1;i<=q;i++){
        if(qr[i]>rm[ql[i]]) puts("No");
        else puts("Yes");
    }

    return 0;
}