/**
    Lost Arrow (Aryan V S)
    Tuesday 2020-12-29
**/

// Solved with a lot of help from Denjell (CF: DenjellBoone). Thanks!

#ifdef LOST_IN_SPACE
#  if   __cplusplus > 201703LL
#    include "lost_pch1.h" // C++20
#  elif __cplusplus > 201402LL
#    include "lost_pch2.h" // C++17
#  else
#    include "lost_pch3.h" // C++14
#  endif
#else
#  include <bits/stdc++.h>
#endif

// Y Combinator: Fixed-Point Combinator in Untyped Lambda Calculus
// Y = Lf.(Lx.f(x x))(Lx.f(x x))
// The Y combinator is a formula which lets you implement recursion in a situation
// where functions can't have names but can be passed around as arguments, used as
// return values, and defined within other functions.
//
// Sources:
// https://www.wikiwand.com/en/Fixed-point_combinator#/Fixed_point_combinators_in_lambda_calculus
// https://yongweiwu.wordpress.com/2014/12/14/y-combinator-and-cplusplus/
// https://stackoverflow.com/questions/93526/what-is-a-y-combinator (https://stackoverflow.com/q/93526/14339850)

template <typename T>
class y_combinator {
  private:
    T t;
  public:
    template <typename U>
    constexpr y_combinator (const U& u) : t (u) { }

    template <typename... Args>
    decltype(auto) operator () (Args&&... args) {
        return t(std::ref(*this), std::forward <Args> (args)...);
    }
};

template <typename T>
y_combinator (T&&) -> y_combinator <std::decay_t <T>>;

struct node {
    int64_t value = 0;
    int64_t lazy  = 0;
    bool lazy_assign = false;
};

int main () {

    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.precision(10);
    std::cerr.precision(10);
    std::cout << std::fixed << std::boolalpha;
    std::cerr << std::fixed << std::boolalpha;

    int n, m;
    std::cin >> n >> m;

    std::vector <node> tree (4 * n);

    auto push = [&] (int v, int tl, int tr, int tm) {
        if (tree [v].lazy_assign) {
            tree [2 * v + 1].value = (tm - tl + 1) * tree [v].lazy;
            tree [2 * v + 2].value = (tr - tm) * tree [v].lazy;
            tree [2 * v + 1].lazy = tree [v].lazy;
            tree [2 * v + 2].lazy = tree [v].lazy;
            tree [2 * v + 1].lazy_assign = true;
            tree [2 * v + 2].lazy_assign = true;
        }
        else {
            tree [2 * v + 1].value += (tm - tl + 1) * tree [v].lazy;
            tree [2 * v + 2].value += (tr - tm) * tree [v].lazy;
            tree [2 * v + 1].lazy += tree [v].lazy;
            tree [2 * v + 2].lazy += tree [v].lazy;
        }
        tree [v].lazy = 0;
        tree [v].lazy_assign = false;
    };

    auto update_assign = y_combinator([&] (auto self, int v, int tl, int tr, int l, int r, int64_t val) -> void {
        if (l > r)
            return;
        if (tl == l && tr == r) {
            tree [v].value = (tr - tl + 1) * val;
            tree [v].lazy  = val;
            tree [v].lazy_assign = true;
        }
        else {
            int tm = (tl + tr) / 2;
            push(v, tl, tr, tm);
            self(2 * v + 1, tl, tm, l, std::min(r, tm), val);
            self(2 * v + 2, tm + 1, tr, std::max(l, tm + 1), r, val);
            tree [v].value = tree [2 * v + 1].value + tree [2 * v + 2].value;
        }
    });

    auto update_add = y_combinator([&] (auto self, int v, int tl, int tr, int l, int r, int64_t val) -> void {
        if (l > r)
            return;
        if (tl == l && tr == r) {
            tree [v].value += (tr - tl + 1) * val;
            tree [v].lazy  += val;
        }
        else {
            int tm = (tl + tr) / 2;
            push(v, tl, tr, tm);
            self(2 * v + 1, tl, tm, l, std::min(r, tm), val);
            self(2 * v + 2, tm + 1, tr, std::max(l, tm + 1), r, val);
            tree [v].value = tree [2 * v + 1].value + tree [2 * v + 2].value;
        }
    });

    auto sum = y_combinator([&] (auto self, int v, int tl, int tr, int l, int r) -> int64_t {
        if (l > r)
            return 0;
        if (tl == l && tr == r)
            return tree [v].value;
        int tm = (tl + tr) / 2;
        push(v, tl, tr, tm);
        return self(2 * v + 1, tl, tm, l, std::min(r, tm)) + self(2 * v + 2, tm + 1, tr, std::max(l, tm + 1), r);
    });

    while (m--) {
        int t, l, r, v;
        std::cin >> t >> l >> r;
        --r;
        if (t == 1) {
            std::cin >> v;
            update_assign(0, 0, n - 1, l, r, v);
        }
        else if (t == 2) {
            std::cin >> v;
            update_add(0, 0, n - 1, l, r, v);
        }
        else {
            std::cout << sum(0, 0, n - 1, l, r) << '\n';
        }
    }

    return 0;
}