#include <iostream>
#include <vector>
#include <algorithm>
#include <fstream>

using namespace std;

typedef long long int64;

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

    static Node *Merge(Node *left, Node *right) {
        int64 sum = 0;
        if (left != NULL)
            sum += left->sum;
        if (right != NULL)
            sum += right->sum;
        return new Node(sum, left, right);
    }
};

class SegmentTree {
  public:
    SegmentTree(const vector<int> &values):
      size(int(values.size())),
      root(NULL) {
        root = Build(0, size - 1, values);
    }
    
    SegmentTree(const int _size, Node *_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;
    Node *root;
    
    Node *Build(const int left, const int right, const vector<int> &values) const {
        if (left > right)
            return NULL;
        int middle = (left + right) / 2;
        if (left == right)
            return new Node(values[middle]);
        return Node::Merge(Build(left, middle, values), Build(middle + 1, right, values));
    }
    
    Node *Push(Node *node, const int left, const int right) const {
        if (node == NULL)
            return NULL;
        int middle = (left + right) / 2;
        if (node->add == 0 || left == right)
            return new Node(node->sum, node->left, node->right);
        Node *newLeft = Update(node->left, left, middle, left, middle, node->add);
        Node *newRight = Update(node->right, middle + 1, right, middle + 1, right, node->add);
        return Node::Merge(newLeft, newRight);
    }
    
    Node *Update(Node *node, const int left, const int right, const int from, const int to, const int value) const {
        if (node == NULL)
            return NULL;
        int middle = (left + right) / 2;
        if (from <= left && right <= to) {
            Node *newNode = new Node(node->sum + 1LL * value * (right - left + 1), node->left, node->right);
            newNode->add = node->add + value;
            return newNode;
        }
        Node *newNode = Push(node, left, right);
        if (from <= middle)
            newNode->left = Update(newNode->left, left, middle, from, to, value);
        if (middle < to)
            newNode->right = Update(newNode->right, middle + 1, right, from, to, value);
        return Node::Merge(newNode->left, newNode->right);
    }
    
    int64 Query(Node *node, const int left, const int right, const int from, const int to, const int64 add) const {
        if (node == NULL)
            return 0;
        int middle = (left + right) / 2;
        if (from <= left && right <= to)
            return node->sum + add * (right - left + 1);
        int64 sum = 0;
        if (from <= middle)
            sum += Query(node->left, left, middle, from, to, add + node->add);
        if (middle < right)
            sum += Query(node->right, middle + 1, right, from, to, add + node->add);
        return sum;
    }
};

int main() {
    //ifstream cin("ants.in");
    //ofstream cout("ants.out");
    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);
        cout << S << "\n";
    }
    return 0;
}
