#include <bits/stdc++.h>

#define FAST_ALLOCATOR_MEMORY 533000000

#ifdef FAST_ALLOCATOR_MEMORY
    int allocator_pos = 0;
    char allocator_memory[(int)FAST_ALLOCATOR_MEMORY];
    inline void * operator new ( size_t n ) {
        char *res = allocator_memory + allocator_pos;
        allocator_pos += n;
        assert(allocator_pos <= (int)FAST_ALLOCATOR_MEMORY);
        return (void *)res;
    }
    inline void operator delete ( void * ) noexcept { }
#endif

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

#define X first
#define Y second
#define inb push_back
#define mk make_pair
#define all(v) v.begin(), v.end()
#define sqr(x) (x) * (x)

int solve();

int main()
{
    solve();
    return 0;
}

struct PersistentSegmentTree
{
    struct Node
    {
        ll val, add;
        Node *l, *r;
        Node() { l = nullptr, r = nullptr; };
        Node(Node *t) : val(t->val), add(t->add), l(t->l), r(t->r) {};
        Node(ll val, Node *l, Node *r) : val(val), add(0), l(l), r(r) {};
        Node(ll val, ll add, Node *l, Node *r) : val(val), add(add), l(l), r(r) {};
    };
    vector<Node*> rts;
    PersistentSegmentTree() { rts.inb(new Node()); };
    PersistentSegmentTree(vector<ll> &a)
    {
        Node *rr = new Node();
        rr = build(rr, 0, a.size() - 1, a);
        rts.inb(rr);
    };
    ll getval(Node *t)
    {
        if (!t)
            return 0;
        return t->val;
    }
    ll getadd(Node *t)
    {
        if (!t)
            return 0;
        return t->add;
    }
    Node * build(Node *t, int tl, int tr, vector<ll> &a)
    {
        if (tl == tr)
            return new Node(a[tl], 0, 0);
        int tm = tl + tr >> 1;
        t->l = new Node();
        t->r = new Node();
        Node *l = build(t->l, tl, tm, a);
        Node *r = build(t->r, tm + 1, tr, a);
        return new Node(getval(l) + getval(r), l, r);
    }
    void push(Node *t, int tl, int tr)
    {
        if (!t || !t->add)
            return;
        int sz = tr - tl + 1;
        t->val += t->add * sz;
        if (tl != tr)
        {
            t->l = new Node(t->l);
            t->r = new Node(t->r);
            t->l->add += t->add;
            t->r->add += t->add;
        }
        t->add = 0;
    }
    Node * update(Node *t, int tl, int tr, int l, int r, ll val)
    {
        push(t, tl, tr);
        if (tl > r || tr < l)
            return 0;
        if (l <= tl && tr <= r)
        {
            Node *res = new Node(t);
            res->add += val;
            push(res, tl, tr);
            return res;
        }
        int tm = tl + tr >> 1;
        Node *L = update(t->l, tl, tm, l, r, val);
        Node *R = update(t->r, tm + 1, tr, l, r, val);
        if (!L)
            L = t->l;
        if (!R)
            R = t->r;
        return new Node(getval(L) + getval(R), L, R);
    }
    ll get(Node *t, int tl, int tr, int l, int r)
    {
        if (tl > r || tr < l)
            return 0;
        if (l <= tl && tr <= r)
            return t->val + t->add * (tr - tl + 1);
        push(t, tl, tr);
        int tm = tl + tr >> 1;
        return get(t->l, tl, tm, l, r) + get(t->r, tm + 1, tr, l, r);
    }
    void print(Node *t, int tl, int tr)
    {
        push(t, tl, tr);
        if (tl == tr)
        {
            printf("%lld ", t->val);
            return;
        }
        int tm = tl + tr >> 1;
        print(t->l, tl, tm);
        print(t->r, tm + 1, tr);
    }
};

int solve()
{
    int n, m;
    scanf("%d %d", &n, &m);
    ll S = 0;
    vector<ll> a(m);
    for (int i = 0; i < m; ++i)
    {
        scanf("%lld", &a[i]);
    }
    PersistentSegmentTree T(a);
    for (int i = 0; i < n - 1; ++i)
    {
        int p, x, y, v, z, t;
        scanf("%d %d %d %d %d %d", &p, &x, &y, &v, &z, &t);
        --p;
        int l = (x + S) % m;
        int r = (y + S) % m;
        int L = (z + S) % m;
        int R = (t + S) % m;
        T.rts.inb(T.update(T.rts[p], 0, m - 1, l, r, v));
        S = T.get(T.rts.back(), 0, m - 1, L, R);
        //printf("TREE %d:\n", i + 1);
        //T.print(T.rts.back(), 0, m - 1);
        //puts("");
        printf("%lld\n", S);
    }
    return 0;
}