#include <cstdio>
#include <cstring>

#include <vector>
#include <algorithm>

using namespace std;

typedef long long int64;

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;
    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 *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 *newLeft = node->left, *newRight = node->right;
        if (from <= middle)
            newLeft = Update(node->left, left, middle, from, to, value);
        if (middle < to)
            newRight = Update(node->right, middle + 1, right, from, to, value);
        Node *newNode = Node::Merge(newLeft, newRight);
        newNode->sum += node->add * (right - left + 1);
        newNode->add = node->add;
        return newNode;
    }
    
    int64 Query(Node *node, const int left, const int right, const int from, const int to, 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;
        add += node->add;
        if (from <= middle)
            sum += Query(node->left, left, middle, from, to, add);
        if (middle < right)
            sum += Query(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;
}
