#include <cstdio>
#include <cstring>

#include <vector>
#include <algorithm>

using namespace std;

typedef long long int64;

const int NIL = -1;
const int MAX_NODES = 4000000;

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);
        }
    }
};

struct Node {
    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) {}
};

int Size, NodeCount;
Node TreeNodes[MAX_NODES];

inline int NewNode(const int64 sum = 0, int left = NIL, int right = NIL) {
    TreeNodes[NodeCount] = Node(sum, left, right);
    return NodeCount++;
}

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);
}
    
int Build(const int left, const int right, const vector<int> &values) {
    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) {
    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;
}

inline int Update(const int root, int from, int to, const int value) {
    from = max(0, from);
    to = min(Size - 1, to);
    if (from > to)
        return root;
    return Update(root, 0, Size - 1, from, to, value);
}

int64 Query(const int node, const int left, const int right, const int from, const int to, int64 add) {
    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;
}

inline int64 Query(const int root, int from, int to) {
    from = max(0, from);
    to = min(Size - 1, to);
    if (from > to)
        return 0;
    return Query(root, 0, Size - 1, from, to, 0);
}

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];
    Size = int(values.size());
    NodeCount = 0;
    vector<int> trees;
    trees.push_back(Build(0, Size - 1, 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(Update(trees[P], uFrom, uTo, V));
        S = Query(trees.back(), qFrom, qTo);
        printf("%lld\n", S);
    }
    return 0;
}
