C++ :

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>

using namespace std;

typedef unsigned long long ullong;
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

const int N = (int)(1e5 + 10);
const ullong MOD = (1ULL << 32);

struct Mat {
  ullong matrix[3][3];
  bool hasV;

  Mat() {
    memset(matrix, 0, sizeof(matrix));
    for (int i = 0; i < 3; i++)
      matrix[i][i] = 1;
    hasV = false;
  }

  Mat(ullong p, ullong q, ullong r, ullong s) {
    matrix[0][0] = (p * p) % MOD;
    matrix[0][1] = (2ULL * (p * q) % MOD) % MOD;
    matrix[0][2] = (q * q) % MOD;
    matrix[1][0] = (p * r) % MOD;
    matrix[1][1] = ((p * s) % MOD + (q * r) % MOD) % MOD;
    matrix[1][2] = (q * s) % MOD;
    matrix[2][0] = (r * r) % MOD;
    matrix[2][1] = (2ULL * (r * s) % MOD) % MOD;
    matrix[2][2] = (s * s) % MOD;
    hasV = true;
  }

  Mat mul(Mat t) {
    Mat c = Mat();
    for (int i = 0; i < 3; i++) {
      for (int j = 0; j < 3; j++) {
        c.matrix[i][j] = 0;
        for (int k = 0; k < 3; k++) {
          c.matrix[i][j] = (c.matrix[i][j] + 
            (t.matrix[i][k] * matrix[k][j]) % MOD) % MOD;
        }
      }
    }
    c.hasV = true;
    return c;
  }

  void show() {
    // for (int i = 0; i < 3; i++) {
    //   for (int j = 0; j < 3; j++)
    //     cout << matrix[i][j] << " ";
    //   cout << endl;
    // }
  }
};

struct Node {
  ullong val[3];

  Node() {
    memset(val, 0, sizeof(val));
  }

  Node(ullong x1, ullong x2, ullong x3) {
    val[0] = x1;
    val[1] = x2;
    val[2] = x3;
  }

  Node add(Node t) {
    return Node(
      (t.val[0] + val[0]) % MOD, 
      (t.val[1] + val[1]) % MOD,
      (t.val[2] + val[2]) % MOD);
  }

  Node mulMat(Mat a) {
    Node c = Node();
    for (int i = 0; i < 3; i++) {
      for (int k = 0; k < 3; k++) {
        c.val[i] = (c.val[i] + (a.matrix[i][k] * val[k]) % MOD) % MOD;
      }
    }
    return c;
  }

};

ullong a[N];
ullong b[N];
Node node[N << 2];
Mat lazy[N << 2];

void pushup(int rt) {
  node[rt] = node[rt << 1].add(node[rt << 1 | 1]);
}

void pushdown(int rt) {
  if (lazy[rt].hasV) {
    lazy[rt << 1] = lazy[rt << 1].mul(lazy[rt]);
    lazy[rt << 1 | 1] = lazy[rt << 1 | 1].mul(lazy[rt]);
    node[rt << 1] = node[rt << 1].mulMat(lazy[rt]);
    node[rt << 1 | 1] = node[rt << 1 | 1].mulMat(lazy[rt]);
    lazy[rt] = Mat();
  }
}

void build(int l, int r, int rt) {
  lazy[rt] = Mat();
  if (l == r) {
    node[rt] = Node((a[l] * a[l]) % MOD, (a[l] * b[l]) % MOD, (b[l] * b[l]) % MOD);
    return ;
  }
  int m = (l + r) >> 1;
  build(lson);
  build(rson);
  pushup(rt);
}

void update(int L, int R, Mat add, int l, int r, int rt) {
  // cout << l << " " << r << endl;
  if (L <= l && r <= R) {
    node[rt] = node[rt].mulMat(add);
    // cout << "before " << endl;
    // lazy[rt].show();
    // add.show();
    lazy[rt] = lazy[rt].mul(add);
    // cout << "after " << endl;
    // lazy[rt].show();
    // cout << endl;
    return ;
  }
  // lazy[rt].show();
  // cout << endl;
  int m = (l + r) >> 1;
  pushdown(rt);
  if (L <= m)
    update(L, R, add, lson);
  if (R > m)
    update(L, R, add, rson);
  pushup(rt);
}

ullong query(int L, int R, int l, int r, int rt) {
  if (L <= l && r <= R) {
    return node[rt].val[1];
  }
  int m = (l + r) >> 1;
  ullong sum = 0;
  pushdown(rt);
  if (L <= m)
    sum = (sum + query(L, R, lson)) % MOD;
  if (R > m)
    sum = (sum + query(L, R, rson)) % MOD;
  pushup(rt);
  return sum;
}

int main() {
  // freopen("rda.in", "r", stdin);
  int n, m;
  scanf("%d %d", &n, &m);
  for (int i = 1; i <= n; i++) 
    scanf("%llu", &a[i]);
  for (int i = 1; i <= n; i++)
    scanf("%llu", &b[i]);
  build(1, n, 1);
  for (int i = 0; i < m; i++) {
    int qs, ll, rr;
    scanf("%d%d%d", &qs, &ll, &rr);
    if (qs == 1) {
      ullong p, q, r, s;
      scanf("%llu %llu %llu %llu", &p, &q, &r, &s);
      Mat add = Mat(p, q, r, s);
      update(ll, rr, add, 1, n, 1);
    }
    else if (qs == 2) {
      ullong res = query(ll, rr, 1, n, 1);
      printf("%llu\n", res);
    }
    else {
      return -1;
    }
    // cout << query(1, n, 1, n, 1) << endl; 
  }
  return 0;
}