#include <cstdio>
#include <cstring>

#include <vector>
#include <algorithm>

using namespace std;

typedef long long int64;

const int NIL = -1;

class Reader {
  public:
    Reader(FILE *_stream, const int _size = 1 << 16):
      stream(_stream),
      size(_size),
      pointer(0),
      buffer(new char[size]) {
        fread(buffer, 1, size, stream);
    }
    
    int NextInt() {
        while ((Current() < '0' || Current() > '9') && Current() != '-')
            NextPosition();
        int value = 0;
        bool negative = false;
        if (Current() == '-') {
            negative = true;
            NextPosition();
        }
        while ('0' <= Current() && Current() <= '9') {
            value = value * 10 + Current() - '0';
            NextPosition();
        }
        if (negative)
            value = -value;
        return value;
    }
    
    Reader &operator>>(int &value) {
        value = NextInt();
        return *this;
    }
    
  private:
    FILE *stream;
    int size, pointer;
    char *buffer;
    
    char Current() const {
        return buffer[pointer];
    }
    
    void NextPosition() {
        if (++pointer == size) {
            pointer = 0;
            fread(buffer, 1, size, stream);
        }
    }
};

class Node {
  public:
    int64 sum, add;
    int left, right;
        
    Node(const int64 _sum = 0, int _left = NIL, int _right = NIL):
      sum(_sum),
      add(0),
      left(_left),
      right(_right) {}
};

vector<Node> TreeNodes;

inline int NewNode(const int64 sum = 0, int left = NIL, int right = NIL) {
    TreeNodes.push_back(Node(sum, left, right));
    return int(TreeNodes.size()) - 1;
}

inline int MergeNodes(const int left, const int right) {
    int64 sum = 0;
    if (left != NIL)
        sum += TreeNodes[left].sum;
    if (right != NIL)
        sum += TreeNodes[right].sum;
    return NewNode(sum, left, right);
}

class SegmentTree {
  public:
    SegmentTree(const vector<int> &values):
      size(int(values.size())),
      root(NIL) {
        root = Build(0, size - 1, values);
    }
    
    SegmentTree(const int _size, const int _root):
      size(_size),
      root(_root) {}
    
    SegmentTree Update(int from, int to, const int value) const {
        from = max(0, from);
        to = min(size - 1, to);
        if (from > to)
            return SegmentTree(size, root);
        return SegmentTree(size, Update(root, 0, size - 1, from, to, value));
    }
    
    int64 Query(int from, int to) const {
        from = max(0, from);
        to = min(size - 1, to);
        if (from > to)
            return 0;
        return Query(root, 0, size - 1, from, to, 0);
    }

  private:
    int size, root;
    
    int Build(const int left, const int right, const vector<int> &values) const {
        if (left > right)
            return NIL;
        int middle = (left + right) / 2;
        if (left == right)
            return NewNode(values[middle]);
        return MergeNodes(Build(left, middle, values), Build(middle + 1, right, values));
    }
    
    int Update(const int node, const int left, const int right, const int from, const int to, const int value) const {
        if (node == NIL)
            return NIL;
        int middle = (left + right) / 2;
        if (from <= left && right <= to) {
            int newNode = NewNode(TreeNodes[node].sum + 1LL * value * (right - left + 1), TreeNodes[node].left, TreeNodes[node].right);
            TreeNodes[newNode].add = TreeNodes[node].add + value;
            return newNode;
        }
        int newLeft = TreeNodes[node].left, newRight = TreeNodes[node].right;
        if (from <= middle)
            newLeft = Update(newLeft, left, middle, from, to, value);
        if (middle < to)
            newRight = Update(newRight, middle + 1, right, from, to, value);
        int newNode = MergeNodes(newLeft, newRight);
        TreeNodes[newNode].sum += TreeNodes[node].add * (right - left + 1);
        TreeNodes[newNode].add = TreeNodes[node].add;
        return newNode;
    }
    
    int64 Query(const int node, const int left, const int right, const int from, const int to, int64 add) const {
        if (node == NIL)
            return 0;
        int middle = (left + right) / 2;
        if (from <= left && right <= to)
            return TreeNodes[node].sum + add * (right - left + 1);
        int64 sum = 0;
        add += TreeNodes[node].add;
        if (from <= middle)
            sum += Query(TreeNodes[node].left, left, middle, from, to, add);
        if (middle < right)
            sum += Query(TreeNodes[node].right, middle + 1, right, from, to, add);
        return sum;
    }
};

int main() {
    //freopen("ants.in", "r", stdin);
    Reader cin = Reader(stdin);
    int Q, N;
    cin >> Q >> N;
    --Q;
    vector<int> values = vector<int>(N);
    for (int i = 0; i < N; ++i)
        cin >> values[i];
    vector<SegmentTree> trees;
    trees.push_back(SegmentTree(values));
    int64 S = 0;
    for (; Q > 0; --Q) {
        int P, X, Y, V, Z, T;
        cin >> P >> X >> Y >> V >> Z >> T;
        --P;
        int uFrom = (X + S) % N, uTo = (Y + S) % N;
        int qFrom = (Z + S) % N, qTo = (T + S) % N;
        trees.push_back(trees[P].Update(uFrom, uTo, V));
        S = trees.back().Query(qFrom, qTo);
        printf("%lld\n", S);
    }
    return 0;
}
