Problem: Write a program which manipulates a sequence $A$ = {$a_0, a_1, ..., a_{n-1}$} with the following operations:

* $update(s, t, x)$: change $a_s, a_{s+1}, ..., a_t$ to $x$.
* $getSum(s, t)$: print the sum of $a_s, a_{s+1}, ..., a_t$.



Note that the initial values of $a_i ( i = 0, 1, ..., n-1 )$ are 0.

Constraints

* $1 ≤ n ≤ 100000$
* $1 ≤ q ≤ 100000$
* $0 ≤ s ≤ t < n$
* $-1000 ≤ x ≤ 1000$

Input


$n$ $q$
$query_1$
$query_2$
:
$query_q$


In the first line, $n$ (the number of elements in $A$) and $q$ (the number of queries) are given. Then, $i$-th query $query_i$ is given in the following format:


0 $s$ $t$ $x$


or


1 $s$ $t$


The first digit represents the type of the query. '0' denotes $update(s, t, x)$ and '1' denotes $find(s, t)$.

Output

For each $getSum$ query, print the sum in a line.

Example

Input

6 7
0 1 3 1
0 2 4 -2
1 0 5
1 0 1
0 3 5 3
1 3 4
1 0 5


Output

-5
1
6
8

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;

#pragma warning(disable : 4267) // "int n = (unsigned)size"

using vi = vector<int>; using vvi = vector<vi>; using vvvi = vector<vvi>;
using ll = long long int;
using vll = vector<ll>; using vvll = vector<vll>; using vvvll = vector<vvll>;
using vd = vector<double>; using vvd = vector<vd>; using vvvd = vector<vvd>;
using P = pair<int, int>;
using Pll = pair<ll, ll>;
using cdouble = complex<double>;

const double eps = 1e-7;
const double INFD = numeric_limits<double>::infinity();
#define Loop(i, n) for(int i = 0; i < int(n); i++)
#define Loopll(i, n) for(ll i = 0; i < ll(n); i++)
#define Loop1(i, n) for(int i = 1; i <= int(n); i++)
#define Loopll1(i, n) for(ll i = 1; i <= ll(n); i++)
#define Loopr(i, n) for(int i = int(n) - 1; i >= 0; i--)
#define Looprll(i, n) for(ll i = ll(n) - 1; i >= 0; i--)
#define Loopr1(i, n) for(int i = int(n); i >= 1; i--)
#define Looprll1(i, n) for(ll i = ll(n); i >= 1; i--)
#define Foreach(buf, container) for(auto buf : container)
#define Loopdiag(i, j, h, w, sum) for(int i = ((sum) >= (h) ? (h) - 1 : (sum)), j = (sum) - i; i >= 0 && j < (w); i--, j++)
#define Loopdiagr(i, j, h, w, sum) for(int j = ((sum) >= (w) ? (w) - 1 : (sum)), i = (sum) - j; j >= 0 && i < (h); j--, i++)
#define Loopdiagsym(i, j, h, w, gap) for (int i = ((gap) >= 0 ? (gap) : 0), j = i - (gap); i < (h) && j < (w); i++, j++)
#define Loopdiagsymr(i, j, h, w, gap) for (int i = ((gap) > (h) - (w) - 1 ? (h) - 1 : (w) - 1 + (gap)), j = i - (gap); i >= 0 && j >= 0; i--, j--)
#define Loopitr(itr, container) for(auto itr = container.begin(); itr != container.end(); itr++)
#define printv(vector) Loop(ex_i, vector.size()) { cout << vector[ex_i] << " "; } cout << endl;
#define printmx(matrix) Loop(ex_i, matrix.size()) { Loop(ex_j, matrix[ex_i].size()) { cout << matrix[ex_i][ex_j] << " "; } cout << endl; }
#define quickio() ios::sync_with_stdio(false); cin.tie(0);
#define bitmanip(m,val) static_cast<bitset<(int)m>>(val)
#define Comp(type_t) bool operator<(const type_t &another) const
#define fst first
#define snd second
bool nearlyeq(double x, double y) { return abs(x - y) < eps; }
bool inrange(ll x, ll t) { return x >= 0 && x < t; }
bool inrange(vll xs, ll t) { Foreach(x, xs) if (!(x >= 0 && x < t)) return false; return true; }
int ceillog2(ll x) { int ret = 0;	x--; while (x > 0) { ret++; x >>= 1; } return ret; }
ll rndf(double x) { return (ll)(x + (x >= 0 ? 0.5 : -0.5)); }
ll floorsqrt(ll x) { ll m = (ll)sqrt((double)x); return m + (m * m <= x ? 0 : -1); }
ll ceilsqrt(ll x) { ll m = (ll)sqrt((double)x); return m + (x <= m * m ? 0 : 1); }
ll rnddiv(ll a, ll b) { return (a / b + (a % b * 2 >= b ? 1 : 0)); }
ll ceildiv(ll a, ll b) { return (a / b + (a % b == 0 ? 0 : 1)); }
ll gcd(ll m, ll n) { if (n == 0) return m; else return gcd(n, m % n); }
ll lcm(ll m, ll n) { return m * n / gcd(m, n); }

/*******************************************************/

template<class T>
class SegTree {
protected:
	int n, N; // n is the original size, while N is the extended size
	int base;
	vector<T> nodes;
	int left_of(int id) {
		if (id >= base) return -1;
		else return id * 2 + 1;
	}
	int right_of(int id) {
		if (id >= base) return -1;
		else return id * 2 + 2;
	}
	int parent_of(int id) {
		if (id == 0) return -1;
		else return (id - 1) >> 1;
	}
	// initially, (s, t, 0, N, 0, x, EXCEPTION);
	void update_rec(int s, int t, int l, int r, int id, ll x, ll v) {
		if (v == LLONG_MIN) {
			v = nodes[id].val;
			nodes[id].val = LLONG_MIN;
		}
		if (s == l && t == r) {
			if (x != LLONG_MIN) {
				nodes[id].val = x;
				nodes[id].sum = x * cover_size(id);
			}
			else if (v != LLONG_MIN) {
				nodes[id].val = v;
				nodes[id].sum = v * cover_size(id);
			}
		}
		else {
			int m = (l + r) / 2;
			int id_l = left_of(id);
			int id_r = right_of(id);
			if (s < m && m < t) {
				update_rec(s, m, l, m, id_l, x, v);
				update_rec(m, t, m, r, id_r, x, v);
			}
			else if (s < m) {
				update_rec(s, t, l, m, id_l, x, v);
				if (v != LLONG_MIN) {
					nodes[id_r].val = v;
					nodes[id_r].sum = v * cover_size(id_r);
				}
			}
			else if (m < t) {
				if (v != LLONG_MIN) {
					nodes[id_l].val = v;
					nodes[id_l].sum = v * cover_size(id_l);
				}
				update_rec(s, t, m, r, id_r, x, v);
			}
			nodes[id].val = LLONG_MIN;
			nodes[id].sum = nodes[id_l].sum + nodes[id_r].sum;
		}
	}
	// initially, (s, t, 0, N, 0, x, EXCEPTION);
	ll solve_rec(int s, int t, int l, int r, int id, ll x, ll v) {
		if (s == l && t == r) {
			return nodes[id].sum;
		}
		else {
			int m = (l + r) / 2;
			int id_l = left_of(id);
			int id_r = right_of(id);
			ll v0 = 0, v1 = 0;
			if (s < m && m < t) {
				v0 = solve_rec(s, m, l, m, id_l, x, v);
				v1 = solve_rec(m, t, m, r, id_r, x, v);
			}
			else if (s < m) {
				v0 = solve_rec(s, t, l, m, id_l, x, v);
			}
			else if (m < t) {
				v1 = solve_rec(s, t, m, r, id_r, x, v);
			}
			return v0 + v1;
		}
	}
public:
	SegTree(int n, T init) {
		SegTree::n = n;
		N = (int)pow(2, ceil(log2(n)));
		base = N - 1;
		nodes = vector<T>(base + N, init);
	}
	int cover_size(int id) {
		int cnt = 1;
		while (left_of(id) != -1) {
			id = left_of(id);
			cnt *= 2;
		}
		int l = id - base;
		int r = min(l + cnt, n);
		return max(0, r - l);
	}
	void update(int s, int t, ll x) {
		update_rec(s, t, 0, N, 0, x, LLONG_MIN);
	}
	ll solve(int s, int t) {
		update_rec(s, t, 0, N, 0, LLONG_MIN, LLONG_MIN);
		return solve_rec(s, t, 0, N, 0, LLONG_MIN, LLONG_MIN);
	}
};

struct val_t {
	ll val;
	ll sum;
};

int main() {
	int n; cin >> n;
	int q; cin >> q;
	SegTree<val_t> st(n, { 0, 0 });
	Loop(unused, q) {
		int op; cin >> op;
		int s, t; cin >> s >> t; t++;
		if (op == 0) {
			ll x; cin >> x;
			st.update(s, t, x);
		}
		else {
			cout << st.solve(s, t) << endl;
		}
	}
}