#include <bits/stdc++.h>
#define fin cin
#define fout cout

using namespace std;

//ifstream fin("input.txt");
//ofstream fout("output.txt");

typedef long long ll;
typedef struct item * pitem;

const ll nmax = 110000;

struct hren
{
    pitem t;
    int l, r, val, add, addl, addr;
    hren(pitem _t, int _l, int _r, int _val, int _add, int _addl, int _addr)
    {
        t = _t;
        l = _l;
        r = _r;
        val = _val;
        add = _add;
        addl = _addl;
        addr = _addr;
    }
};

struct item
{
    ll val, add;
    pitem l, r;
    
    item()
    {
        val = 0;
        add = 0;
        l = NULL;
        r = NULL;
    }
};

pitem root[nmax];
ll a[nmax];
ll c[1100][1100];
ll p[nmax], x[nmax], y[nmax], v[nmax], z[nmax], t[nmax];
ll n, m, s;
vector<hren> vv;


void read()
{
    fin >> n >> m;
    for (ll i = 0; i < m; i++)
        fin >> a[i];
    for (ll i = 1; i < n; i++)
    {
        fin >> p[i] >> x[i] >> y[i] >> v[i] >> z[i] >> t[i];
        p[i]--;
    }
}


void build(pitem &T, ll l, ll r)
{
    if (r <= l)
        return;
    //assert(T != NULL);
    if (r - l > 1)
    {
        ll m = (l + r + 1) / 2;
        T->l = new item();
        T->r = new item();
        build(T->l, l, m);
        build(T->r, m, r);
        //assert(m < r);
        T->val = T->l->val + T->r->val;
    }
    else
        T->val = a[l];
}


void update(pitem &T, ll lb, ll rb, ll l, ll r, ll v)
{
    if ((l >= rb) || (r <= lb))
        return;
    if ((l <= lb) && (r >= rb))
    {
        T->add += v;
        return;
    }
    ll m = (lb + rb + 1) / 2;
    update(T->l, lb, m, l, r, v);
    update(T->r, m, rb, l, r, v);
    T->val = T->l->val + T->r->val + T->l->add * (m - lb) + T->r->add * (rb - m);
}


void push(pitem &T, ll l, ll r)
{
    if (T->l != NULL)
        T->l->add += T->add;
    if (T->r != NULL)
        T->r->add += T->add;
    T->val += T->add * (r - l);
    T->add = 0;
}


void fuck(pitem T, ll lb, ll rb, ll l, ll r)
{
    if ((lb >= r) || (l >= rb))
        return;
    ll tladd = -1;
    ll tradd = -1;
    if (T->l != NULL)
        tladd = T->l->add;
    if (T->r != NULL)
        tradd = T->r->add;
    vv.push_back(hren(T, lb, rb, T->val, T->add, tladd, tradd));
    if ((l <= lb) && (r >= rb))
        return;
    ll m = (lb + rb + 1) / 2;
    fuck(T->l, lb, m, l, r);
    fuck(T->r, m, rb, l, r);
}


ll get(pitem T, ll lb, ll rb, ll l, ll r)
{
    if ((lb >= r) || (l >= rb))
        return 0;
    push(T, lb, rb);
    if ((l <= lb) && (r >= rb))
        return T->val + T->add * (rb - lb);
    ll m = (lb + rb + 1) / 2;
    return get(T->l, lb, m, l, r) + get(T->r, m, rb, l, r);
}


void build2(pitem &T, pitem copy_of_t, int lb, int rb, int l, int r)
{
    if ((lb >= r) || (l >= rb))
        return;
    //assert(T != copy_of_t);
    T = new item();
    T->val = copy_of_t->val;
    T->add = copy_of_t->add;
    if (rb - lb > 1)
    {
        int m = (lb + rb + 1) / 2;
        if ((lb >= r) || (l >= m))
            T->l = copy_of_t->l;
        else
            T->l = new item();
        if ((m >= r) || (l >= rb))
            T->r = copy_of_t->r;
        else
            T->r = new item();
        build2(T->l, copy_of_t->l, lb, m, l, r);
        build2(T->r, copy_of_t->r, m, rb, l, r);
    }
}


void backup()
{
    //fout <<  "vvv " << vv.size() << endl;
    for (int i = 0; i < vv.size(); i++)
    {
        if (vv[i].t == NULL)
            continue;
        vv[i].t->add = vv[i].add;
        vv[i].t->val = vv[i].val;
        if (vv[i].t->l != NULL)
            vv[i].t->l->add = vv[i].addl;
        if (vv[i].t->r != NULL)
            vv[i].t->r->add = vv[i].addr;
    }
}


void solve()
{
    s = 0;
    for (ll i = 1; i < n; i++)
    {
        ll l, r, ii, j;
        l = (x[i] + s) % m;
        r = (y[i] + s) % m;
        ii = (z[i] + s) % m;
        j = (t[i] + s) % m;
        //fout << p[i] << endl;
        //for (int iii = 0; iii < m; iii++)
            //for (int jj = iii + 1; jj <= iii + 1; jj++)
                //fout << iii << ' ' << jj << ' ' << get(root[p[i]], 0, m, iii, jj) << endl;
        //fout << l << ' ' << r << ' ' << ii << ' ' << j << ' ' << v[i] << endl;
        root[i] = new item();
        vv.clear();
        build2(root[i], root[p[i]], 0, m, l, r);
        update(root[i], 0, m, l, r + 1, v[i]);
        fuck(root[i], 0, m, ii, j + 1);
        ll add = get(root[i], 0, m, ii, j + 1);
        fout << add << endl;
        //for (int iii = 0; iii < m; iii++)
            //for (int jj = iii + 1; jj <= iii + 1; jj++)
                //fout << iii << ' ' << jj << ' ' << get(root[i], 0, m, iii, jj) << endl;
        backup();
        s = add;
    }
}


int main()
{
    read();
    root[0] = new item();
    build(root[0], 0, m);
    solve();
    return 0;
}
