DZY loves colors, and he enjoys painting.

On a colorful day, DZY gets a colorful ribbon, which consists of n units (they are numbered from 1 to n from left to right). The color of the i-th unit of the ribbon is i at first. It is colorful enough, but we still consider that the colorfulness of each unit is 0 at first.

DZY loves painting, we know. He takes up a paintbrush with color x and uses it to draw a line on the ribbon. In such a case some contiguous units are painted. Imagine that the color of unit i currently is y. When it is painted by this paintbrush, the color of the unit becomes x, and the colorfulness of the unit increases by |x - y|.

DZY wants to perform m operations, each operation can be one of the following:

  1. Paint all the units with numbers between l and r (both inclusive) with color x. 
  2. Ask the sum of colorfulness of the units between l and r (both inclusive). 



Can you help DZY?

Input

The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105).

Each of the next m lines begins with a integer type (1 ≤ type ≤ 2), which represents the type of this operation.

If type = 1, there will be 3 more integers l, r, x (1 ≤ l ≤ r ≤ n; 1 ≤ x ≤ 108) in this line, describing an operation 1.

If type = 2, there will be 2 more integers l, r (1 ≤ l ≤ r ≤ n) in this line, describing an operation 2.

Output

For each operation 2, print a line containing the answer — sum of colorfulness.

Examples

Input

3 3
1 1 2 4
1 2 3 5
2 1 3


Output

8


Input

3 4
1 1 3 4
2 1 1
2 2 2
2 3 3


Output

3
2
1


Input

10 6
1 1 5 3
1 2 7 9
1 10 10 11
1 3 8 12
1 1 10 3
2 1 10


Output

129

Note

In the first sample, the color of each unit is initially [1, 2, 3], and the colorfulness is [0, 0, 0].

After the first operation, colors become [4, 4, 3], colorfulness become [3, 2, 0].

After the second operation, colors become [4, 5, 5], colorfulness become [3, 3, 2].

So the answer to the only operation of type 2 is 8.
#include <bits/stdc++.h>
using namespace std;
long long A[100010];
vector<long long> INQ[1010];
int N;
long long C[100010];
long long CG[100010];
int getNext(int i) {
  int gid = i / 1000;
  return min((gid + 1) * 1000, N);
}
void pushDown(int gid) {
  vector<long long> &V = INQ[gid];
  if (V.size() == 0) return;
  long long s = 0;
  for (int i = 1; i < V.size(); ++i) s += llabs(V[i] - V[i - 1]);
  int last = getNext(gid * 1000);
  for (int i = gid * 1000; i < last; ++i) {
    C[i] += llabs(A[i] - V[0]) + s;
    A[i] = V.back();
  }
  V.clear();
}
void updateGroup(int gid, long long x) {
  vector<long long> &V = INQ[gid];
  int l = getNext(gid * 1000);
  if (V.size() > 0) {
    CG[gid] += 1LL * llabs(V.back() - x) * (l - gid * 1000);
    V.push_back(x);
  } else {
    for (int i = gid * 1000; i < l; ++i) CG[gid] += llabs(A[i] - x);
    V.push_back(x);
  }
}
void updatePiece(int i, int j, long long x) {
  int gid = i / 1000;
  pushDown(gid);
  for (int k = i; k <= j; ++k) {
    CG[gid] += llabs(A[k] - x);
    C[k] += llabs(A[k] - x);
    A[k] = x;
  }
}
long long getGroup(int gid) { return CG[gid]; }
long long getPiece(int i, int j) {
  int gid = i / 1000;
  pushDown(gid);
  long long s = 0;
  for (int k = i; k <= j; ++k) s += C[k];
  return s;
}
void update(int i, int j, long long x) {
  int gn = getNext(i);
  if (gn > j)
    updatePiece(i, j, x);
  else {
    updatePiece(i, gn - 1, x);
    i = gn;
    while (i / 1000 != j / 1000) {
      updateGroup(i / 1000, x);
      i = getNext(i);
    }
    updatePiece(i, j, x);
  }
}
long long get(int i, int j) {
  long long ans = 0;
  int gn = getNext(i);
  if (gn > j)
    ans += getPiece(i, j);
  else {
    ans += getPiece(i, gn - 1);
    i = gn;
    while (i / 1000 != j / 1000) {
      ans += getGroup(i / 1000);
      i = getNext(i);
    }
    ans += getPiece(i, j);
  }
  return ans;
}
int main() {
  int M = 0;
  cin >> N >> M;
  for (int i = 0; i < N; ++i) {
    A[i] = i + 1;
  }
  for (int i = 0; i < M; ++i) {
    int c;
    cin >> c;
    if (c == 1) {
      int l, r;
      long long x;
      cin >> l >> r >> x;
      l--;
      r--;
      update(l, r, x);
    } else {
      int l, r;
      cin >> l >> r;
      l--;
      r--;
      cout << get(l, r) << endl;
    }
  }
}
