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.
// practice with rainboy
import java.io.*;
import java.util.*;

public class CF444C extends PrintWriter {
	CF444C() { super(System.out, true); }
	Scanner sc = new Scanner(System.in);
	public static void main(String[] $) {
		CF444C o = new CF444C(); o.main(); o.flush();
	}

	static final int K = 320;
	int[] cc, cc_;
	long[] kk, kk_;
	long push(int a) {
		int c_ = cc_[a];
		if (c_ == 0)
			return 0;
		long k_ = kk_[a];
		kk_[a] = 0;
		cc_[a] = 0;
		for (int i = a * K; i < (a + 1) * K; i++) {
			kk[i] += k_;
			cc[i] = c_;
		}
		return k_ * K;
	}
	long update(int l, int r, int c) {
		long s = 0;
		for (int i = l; i < r; i++) {
			int d = Math.abs(cc[i] - c);
			kk[i] += d; s += d;
			cc[i] = c;
		}
		return s;
	}
	long query(int l, int r) {
		long s = 0;
		for (int i = l; i < r; i++)
			s += kk[i];
		return s;
	}
	void main() {
		int n = sc.nextInt();
		int m = sc.nextInt();
		int b = (n + K - 1) / K;
		cc = new int[b * K];
		kk = new long[b * K];
		cc_ = new int[b];
		kk_ = new long[b];
		long[] ss = new long[b];
		for (int i = 0; i < n; i++)
			cc[i] = i + 1;
		while (m-- > 0) {
			int t = sc.nextInt();
			int l = sc.nextInt() - 1;
			int r = sc.nextInt() - 1;
			int l_ = l / K, r_ = r / K;
			if (t == 1) {
				int c = sc.nextInt();
				if (l_ == r_) {
					ss[l_] += push(l_);
					ss[l_] += update(l, r + 1, c);
				} else {
					ss[l_] += push(l_);
					ss[l_] += update(l, (l_ + 1) * K, c);
					for (int a = l_ + 1; a < r_; a++) {
						if (cc_[a] != 0)
							kk_[a] += Math.abs(cc_[a] - c);
						else
							ss[a] += update(a * K, (a + 1) * K, c);
						cc_[a] = c;
					}
					ss[r_] += push(r_);
					ss[r_] += update(r_ * K, r + 1, c);
				}
			} else {
				long ans = 0;
				if (l_ == r_) {
					ss[l_] += push(l_);
					ans = query(l, r + 1);
				} else {
					ss[l_] += push(l_);
					ans += query(l, (l_ + 1) * K);
					for (int a = l_ + 1; a < r_; a++) {
						if (cc_[a] != 0)
							ans += kk_[a] * K;
						ans += ss[a];
					}
					ss[r_] += push(r_);
					ans += query(r_ * K, r + 1);
				}
				println(ans);
			}
		}
	}
}
