#include <bits/stdc++.h>
using namespace std;
template<typename T>
int SIZE(T (&t)){
    return t.size();
}

template<typename T, size_t N>
int SIZE(T (&t)[N]){
    return N;
}

string to_string(char t){
    return "'" + string({t}) + "'";
}

string to_string(bool t){
    return t ? "true" : "false";
}

string to_string(const string &t, int x1=0, int x2=1e9){
    string ret = "";
    for(int i = min(x1,SIZE(t)), _i = min(x2,SIZE(t)-1); i <= _i; ++i){
        ret += t[i];
    }
    return '"' + ret + '"';
}

string to_string(const char* t){
    string ret(t);
    return to_string(ret);
}

template<size_t N>
string to_string(const bitset<N> &t, int x1=0, int x2=1e9){
    string ret = "";
    for(int i = min(x1,SIZE(t)); i <= min(x2,SIZE(t)-1); ++i){
        ret += t[i] + '0';
    }
    return to_string(ret);
}

template<typename T, typename... Coords>
string to_string(const T (&t), int x1=0, int x2=1e9, Coords... C);

template<typename T, typename S>
string to_string(const pair<T, S> &t){
    return "(" + to_string(t.first) + ", " + to_string(t.second) + ")";
}

template<typename T, typename... Coords>
string to_string(const T (&t), int x1, int x2, Coords... C){
    string ret = "[";
    x1 = min(x1, SIZE(t));
    auto e = begin(t);
    advance(e,x1);
    for(int i = x1, _i = min(x2,SIZE(t)-1); i <= _i; ++i){
        ret += to_string(*e, C...) + (i != _i ? ", " : "");
        e = next(e);
    }
    return ret + "]";
}

template<int Index, typename... Ts>
struct print_tuple{
    string operator() (const tuple<Ts...>& t) {
        string ret = print_tuple<Index - 1, Ts...>{}(t);
        ret += (Index ? ", " : "");
        return ret + to_string(get<Index>(t));
    }
};

template<typename... Ts>
struct print_tuple<0, Ts...> {
    string operator() (const tuple<Ts...>& t) {
        return to_string(get<0>(t));
    }
};

template<typename... Ts>
string to_string(const tuple<Ts...>& t) {
    const auto Size = tuple_size<tuple<Ts...>>::value;
    return print_tuple<Size - 1, Ts...>{}(t);
}

void dbgr(){;}
template<typename Heads, typename... Tails>
void dbgr(Heads H, Tails... T){
    cout << to_string(H) << " | ";
    dbgr(T...);
}

void dbgs(){;}
template<typename Heads, typename... Tails>
void dbgs(Heads H, Tails... T){
    cout << H << " ";
    dbgs(T...);
}

/*
formatted functions:
*/

/*
consider __VA_ARGS__ as a whole:
dbgv() prints values only
dbg() prints name and values
*/
#define dbgv(...) cout << to_string(__VA_ARGS__) << endl;

#define dbg(...) cout << "[" << #__VA_ARGS__ << "]: "; dbgv(__VA_ARGS__);
//#define dbg(...)

/*
consider __VA_ARGS__ as a sequence of arguments:
dbgr() prints values only
dbgm() prints names and values
*/
#define dbgr(...) dbgr(__VA_ARGS__); cout << endl;

#define dbgm(...) cout << "[" << #__VA_ARGS__ << "]: "; dbgr(__VA_ARGS__);

struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};

typedef long long ll;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<ll, ll> pll;
// using u128 = __uint128_t;
// using i128 = __int128;
const int mod = 1000000007;
const int N = 200005;
const int LOG = 20;
const int inf = 1e9;
const double eps = 1e-11;
int n, m, k, qq;
int a[N], f[N];
vector<int> adj[N];
vector<array<int, 3>> sweep[N];
vector<array<int, 4>> sweepq[N];
ll out[N];
set<int> s[N];
void addrect(int z, int x, int y) {
    if (x > y) swap(x, y);
    if (x < z && y < z) {
        // dbgm(z, x, y, 0);
        sweep[0].push_back({y, z - 1, 1});
        sweep[x + 1].push_back({y, z - 1, -1});
    }
    
    if (x > z && y > z) {
        // dbgm(z, x, y, 1);
        sweep[z + 1].push_back({y, n - 1, 1});
        sweep[x + 1].push_back({y, n - 1, -1});
    }
}

void dfs(int u) {
    for (int &v : adj[u]) {
        dfs(v);
        if (s[v].size() > s[adj[u][0]].size()) {
            swap(v, adj[u][0]);
        }
    }
    
    if (!adj[u].empty()) swap(s[u], s[adj[u][0]]);
    for (int &v : adj[u]) {
        if (v == adj[u][0]) continue;
        for (int x : s[v]) {
            auto it = s[u].upper_bound(x);
            if (it != s[u].end()) {
                int y = *it;
                addrect(a[u], x, y);
            }
            
            if (it != s[u].begin()) {
                it--;
                int y = *it;
                addrect(a[u], x, y);
            } 
        }
        
        for (int x : s[v]) {
            s[u].insert(x);
        }
    }
    
    s[u].insert(a[u]);
}

struct Node {
    int mn = 0, cnt = 1, lazy = 0, lazyadd = 0;
    ll sum = 0;  
};

Node t[N * 4];
const int dummy = N * 4 - 1;
void push(int u, int v) {
    t[v].mn += t[u].lazyadd, t[v].lazyadd += t[u].lazyadd;
    if (t[u].mn == t[v].mn) {
        t[v].sum += (ll)t[v].cnt * t[u].lazy, t[v].lazy += t[u].lazy;
    }
}

void prop(int v) {
    push(v, v * 2);
    push(v, v * 2 + 1);
    t[v].lazy = 0, t[v].lazyadd = 0;
}

void comb(int v) {
    t[v].sum = t[v * 2].sum + t[v * 2 + 1].sum;
    t[v].mn = t[v * 2].mn, t[v].cnt = t[v * 2].cnt;
    if (t[v * 2 + 1].mn < t[v].mn) {
        t[v].mn = t[v * 2 + 1].mn, t[v].cnt = t[v * 2 + 1].cnt;
    }
    
    if (t[v * 2 + 1].mn == t[v].mn) t[v].cnt += t[v * 2 + 1].cnt;
}

void build(int v = 1, int tl = 0, int tr = n - 1) {
    if (tl == tr) return;
    int mid = (tl + tr) / 2;
    build(v * 2, tl, mid);
    build(v * 2 + 1, mid + 1, tr);
    comb(v);
}

void update(int ql, int qr, int x, int v = 1, int tl = 0, int tr = n - 1) {
    if (tl > qr || tr < ql) return;
    if (tl >= ql && tr <= qr) {
        t[dummy].lazyadd = x;
        push(dummy, v);
        return;
    }
    
    prop(v);
    int mid = (tl + tr) / 2;
    update(ql, qr, x, v * 2, tl, mid);
    update(ql, qr, x, v * 2 + 1, mid + 1, tr);
    comb(v);
}

ll query(int ql, int qr, int v = 1, int tl = 0, int tr = n - 1) {
    if (tl > qr || tr < ql) return 0;
    if (tl >= ql && tr <= qr) return t[v].sum;
    prop(v);
    int mid = (tl + tr) / 2;
    ll L = query(ql, qr, v * 2, tl, mid);
    ll R = query(ql, qr, v * 2 + 1, mid + 1, tr);
    return L + R;
}

void solve() {
    t[dummy].lazy = 1;
    cin >> n >> qq;
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        a[i]--;
    }
    
    for (int i = 1; i < n; i++) {
        cin >> f[i];
        f[i]--;
        adj[f[i]].push_back(i);
    }
    
    // dbg(adj);
    build();
    dfs(0);
    for (int i = 0; i < qq; i++) {
        int l, r;
        cin >> l >> r;
        l--, r--;
        int sz = r - l + 1;
        out[i] = (ll)sz * (1 - sz) / 2;
        if (l != 0) sweepq[l - 1].push_back({l, r, -1, i});
        sweepq[r].push_back({l, r, 1, i});
    }
    
    for (int i = 0; i < n; i++) {
        vector<pi> pos;
        for (auto [l, r, x] : sweep[i]) {
            pos.push_back({l, x});
            pos.push_back({r + 1, -x});
        }
        
        sort(pos.begin(), pos.end());
        pos.push_back({n, 0});
        // dbg(pos);
        int pre = 0, cur = 0;
        for (auto [p, x] : pos) {
            if (pre != p) {
                // dbgm(pre, p - 1, cur, i);
                update(pre, p - 1, cur);
                pre = p;
            }
            
            cur += x;
        }
        
        for (auto [l, r, x, j] : sweepq[i]) {
            // dbgm(query(l, r), x);
            out[j] += query(l, r) * x;
        }
    }
    
    for (int i = 0; i < qq; i++) {
        cout << out[i] << "\n";
    }
}

int32_t main() {
    std::ios::sync_with_stdio(false);
    cin.tie(NULL);
    solve();
}