#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


using U = unsigned long long;

int N, M, Q;
vector<int> O, L, R, X;
vector<U> V;


namespace brute {
vector<U> run() {
  vector<set<int>> on(N);
  for (int i = 0; i < N; ++i) {
    for (int j = 0; j <= M; ++j) {
      on[i].insert(j);
    }
  }
  vector<U> ws(N, 0);
  vector<U> ans(Q, 0);
  for (int q = 0; q < Q; ++q) {
    if (O[q] == 1) {
      for (int i = L[q]; i < R[q]; ++i) on[i].erase(X[q]);
    } else if (O[q] == 2) {
      for (int i = L[q]; i < R[q]; ++i) on[i].insert(X[q]);
    } else if (O[q] == 3) {
      int mn = M + 1;
      for (int i = L[q]; i < R[q]; ++i) chmin(mn, *on[i].begin());
      for (int i = L[q]; i < R[q]; ++i) if (mn == *on[i].begin()) ws[i] += V[q];
    } else {
      for (int i = L[q]; i < R[q]; ++i) ans[q] += ws[i];
    }
// for(int i=0;i<N;++i){cerr<<i<<": ";pv(on[i].begin(),on[i].end());}
  }
  return ans;
}
}  // brute


namespace fast {
struct Node {
  priority_queue<int, vector<int>, greater<int>> que, queRem;
  int mn;
  int cnt, cntAll;
  U sum, lz, lzAll;
  Node() : que{}, queRem{}, mn(M + 1), cnt(0), cntAll(0), sum(0), lz(0), lzAll(0) {}
  void push(Node &l, Node &r) {
    if (lz) {
      assert(mn <= que.top());
      if (mn == que.top()) {
        l.addAll(lz);
        r.addAll(lz);
      } else {
        if (mn == l.mn) l.add(lz);
        if (mn == r.mn) r.add(lz);
      }
      lz = 0;
    }
    if (lzAll) {
      l.addAll(lzAll);
      r.addAll(lzAll);
      lzAll = 0;
    }
  }
  void pull(const Node &l, const Node &r) {
    const int mnL = min(que.top(), l.mn);
    const int mnR = min(que.top(), r.mn);
    if (mnL < mnR) {
      mn = mnL;
      cnt = l.cnt;
    } else if (mnL > mnR) {
      mn = mnR;
      cnt = r.cnt;
    } else {
      mn = mnL;
      cnt = l.cnt + r.cnt;
    }
    cntAll = l.cntAll + r.cntAll;
    sum = l.sum + r.sum;
  }
  void paint(int x, int col) {
    (col ? que : queRem).push(x);
    for (; !queRem.empty() && que.top() == queRem.top(); que.pop(), queRem.pop()) {}
    // for leaf
    mn = que.top();
  }
  void add(U val) {
    sum += cnt * val;
    lz += val;
  }
  void addAll(U val) {
    sum += cntAll * val;
    lzAll += val;
  }
};

int segN;
vector<Node> seg;
void push(int u) {
  if (u < segN) seg[u].push(seg[u << 1], seg[u << 1 | 1]);
}
void pull(int u) {
  if (u < segN) seg[u].pull(seg[u << 1], seg[u << 1 | 1]);
}
void paint(int u, int l, int r, int a, int b, int x, int col) {
  if (b <= l || r <= a) return;
  push(u);
  if (a <= l && r <= b) {
    seg[u].paint(x, col);
    pull(u);
    return;
  }
  const int mid = (l + r) / 2;
  paint(u << 1    , l, mid, a, b, x, col);
  paint(u << 1 | 1, mid, r, a, b, x, col);
  pull(u);
}
void paint(int a, int b, int x, int col) {
  paint(1, 0, segN, a, b, x, col);
}
void add(int u, int l, int r, int a, int b, int tar, int anc, U val) {
// cerr<<"add "<<u<<" ["<<l<<", "<<r<<") ["<<a<<", "<<b<<") tar="<<tar<<" anc="<<anc<<" val="<<val<<endl;
  if (b <= l || r <= a) return;
  push(u);
  if (a <= l && r <= b) {
    const int mn = min(anc, seg[u].mn);
    assert(tar <= mn);
    if (tar == mn) {
// cerr<<"  added ["<<l<<", "<<r<<") tar="<<tar<<" anc="<<anc<<" seg[u].mn="<<seg[u].mn<<" mn="<<mn<<endl;
      if (tar == anc) {
        seg[u].addAll(val);
      } else {
        seg[u].add(val);
      }
    }
    return;
  }
  chmin(anc, seg[u].que.top());
  const int mid = (l + r) / 2;
  add(u << 1    , l, mid, a, b, tar, anc, val);
  add(u << 1 | 1, mid, r, a, b, tar, anc, val);
  pull(u);
}
void add(int a, int b, int tar, int anc, U val) {
  add(1, 0, segN, a, b, tar, anc, val);
}
int getMin(int u, int l, int r, int a, int b) {
  if (b <= l || r <= a) return M + 1;
  if (a <= l && r <= b) return seg[u].mn;
  push(u);
  const int mid = (l + r) / 2;
  const int resL = getMin(u << 1    , l, mid, a, b);
  const int resR = getMin(u << 1 | 1, mid, r, a, b);
  pull(u);
  return min(seg[u].que.top(), min(resL, resR));
}
int getMin(int a, int b) {
  return getMin(1, 0, segN, a, b);
}
U getSum(int u, int l, int r, int a, int b) {
  if (b <= l || r <= a) return 0;
  if (a <= l && r <= b) return seg[u].sum;
  push(u);
  const int mid = (l + r) / 2;
  const U resL = getSum(u << 1    , l, mid, a, b);
  const U resR = getSum(u << 1 | 1, mid, r, a, b);
  pull(u);
  return resL + resR;
}
U getSum(int a, int b) {
  return getSum(1, 0, segN, a, b);
}

vector<U> run() {
  for (segN = 1; segN < N; segN <<= 1) {}
  seg.assign(segN << 1, Node());
  for (int u = 1; u < segN << 1; ++u) seg[u].que.push(M + 1);
  for (int i = 0; i < N; ++i) seg[segN + i].cnt = seg[segN + i].cntAll = 1;
  for (int u = segN; --u >= 1; ) pull(u);
  vector<set<pair<int, int>>> pss(M + 1);
  for (int x = 0; x <= M; ++x) {
    paint(0, N, x, 1);
    pss[x].emplace(N, -0);
  }
#ifdef LOCAL
vector<vector<int>>board(M,vector<int>(N,1));
#endif
  vector<U> ans(Q, 0);
  for (int q = 0; q < Q; ++q) {
    if (O[q] == 1) {
// cerr<<COLOR("33")<<O[q]<<" ["<<L[q]<<", "<<R[q]<<") "<<X[q]<<COLOR()<<endl;
      const int x = X[q];
      const int l = L[q], r = R[q];
      int psLen = 0;
      pair<int, int> ps[2];
      for (auto it = pss[x].lower_bound(make_pair(l, l)); it != pss[x].end(); it = pss[x].erase(it)) {
        const int ll = -it->second, rr = it->first;
        if (r <= ll) break;
        if (ll < l) ps[psLen++] = make_pair(l, -ll);
        if (r < rr) ps[psLen++] = make_pair(rr, -r);
        paint(ll, rr, x, 0);
      }
      for (int j = 0; j < psLen; ++j) {
        const int ll = -ps[j].second, rr = ps[j].first;
        paint(ll, rr, x, 1);
        pss[x].insert(ps[j]);
      }
#ifdef LOCAL
for(int i=L[q];i<R[q];++i)board[X[q]][i]=0;
int sum=0;
for(int i=0;i<N;++i)sum+=board[X[q]][i];
for(const auto&p:pss[X[q]])for(int i=-p.second;i<p.first;++i){assert(board[X[q]][i]);--sum;}
assert(sum==0);
#endif
    } else if (O[q] == 2) {
// cerr<<COLOR("33")<<O[q]<<" ["<<L[q]<<", "<<R[q]<<") "<<X[q]<<COLOR()<<endl;
      const int x = X[q];
      int l = L[q], r = R[q];
      for (auto it = pss[x].lower_bound(make_pair(l, l)); it != pss[x].end(); it = pss[x].erase(it)) {
        const int ll = -it->second, rr = it->first;
        if (r <= ll) break;
        paint(ll, rr, x, 0);
        chmin(l, ll);
        chmax(r, rr);
      }
      paint(l, r, x, 1);
      pss[x].emplace(r, -l);
#ifdef LOCAL
for(int i=L[q];i<R[q];++i)board[X[q]][i]=1;
int sum=0;
for(int i=0;i<N;++i)sum+=board[X[q]][i];
for(const auto&p:pss[X[q]])for(int i=-p.second;i<p.first;++i){assert(board[X[q]][i]);--sum;}
assert(sum==0);
#endif
    } else if (O[q] == 3) {
// cerr<<COLOR("33")<<O[q]<<" ["<<L[q]<<", "<<R[q]<<") "<<V[q]<<COLOR()<<endl;
      const int tar = getMin(L[q], R[q]);
      add(L[q], R[q], tar, M + 1, V[q]);
#ifdef LOCAL
vector<int>mns(N,M);
for(int x=0;x<M;++x)for(int i=0;i<N;++i)if(board[x][i])chmin(mns[i],x);
cerr<<"  mns = "<<mns<<endl;
cerr<<"  tar = "<<tar<<endl;
#endif
    } else {
      ans[q] = getSum(L[q], R[q]);
    }
  }
  return ans;
}
}  // fast


int main() {
  for (; ~scanf("%d%d", &N, &Q); ) {
    O.resize(Q);
    L.resize(Q);
    R.resize(Q);
    X.assign(Q, -1);
    V.assign(Q, 0);
    for (int q = 0; q < Q; ++q) {
      scanf("%d%d%d", &O[q], &L[q], &R[q]);
      --L[q];
      if (O[q] == 1 || O[q] == 2) {
        scanf("%d", &X[q]);
        --X[q];
      } else if (O[q] == 3) {
        scanf("%llu", &V[q]);
      }
    }
    M = max(*max_element(X.begin(), X.end()), 0) + 1;
cerr<<"N = "<<N<<", M = "<<M<<", Q = "<<Q<<endl;
    
    const auto ans = fast::run();
    for (int q = 0; q < Q; ++q) if (O[q] == 4) {
      printf("%llu\n", ans[q]);
    }
#ifdef LOCAL
if(N<=1000&&Q<=1000){
 const auto brt=brute::run();
 for(int q=0;q<Q;++q)if(brt[q]!=ans[q]){cerr<<q<<": "<<brt[q]<<" "<<ans[q]<<endl;break;}
 assert(brt==ans);
}
#endif
  }
  return 0;
}