It is possible, basically you express the lazy tag (F in the implementation) as a pair $$$(a, b)$$$ where you first assign all values in the range to $$$a$$$, then you add $$$b$$$ to all values. Also have some sentinel value for $$$a$$$ to indicate no range set operation (e.g. $$$0$$$). When you apply $$$(c, d)$$$ after $$$(a, b)$$$, the new lazy tag becomes $$$(c, d)$$$, and when you apply $$$(0, d)$$$ after $$$(a, b)$$$, it becomes $$$(a, b + d)$$$.

Your task is to maintain an array $$$t(n)$$$, let's try to add query $$$0$$$:

$$$0.$$$ For each $$$i=[l,r]$$$ set $$$t_i←a×t_i$$$ + b.
$$$1.$$$ Increase each value in range $$$[l,r]$$$ by $$$x$$$.
$$$2.$$$ Set each value in range $$$[l,r]$$$ to $$$x$$$.
$$$3.$$$ Calculate the sum of values in range $$$[l,r]$$$.

Then the problem can be reduced to:

$$$0.$$$ For each $$$i=[l,r]$$$ set $$$t_i←a×t_i$$$ + b.
$$$1.$$$ Query $$$0$$$ with $$$(a, b) = (1, x)$$$.
$$$2.$$$ Query $$$0$$$ with $$$(a, b) = (0, x)$$$.
$$$3.$$$ Calculate the sum of values in range $$$[l,r]$$$.

This is known as Range Affine Range Sum, you can read the editorial here

We will define functions corresponding with atcoder lazysegtree document

• $$$S\text{{sum, sz}}$$$ represents the sum of all elements and the sequence length.

• $$$F\text{{a, b}}$$$ represents the form $$$f(x) = ax + b$$$

• $$$op(S\ l, S\ r) = $$$ { $$$l_{sum} + r_{sum}, l_{sz} + r_{sz}$$$ }

• $$$\text{e() = S{0, 0}}$$$ because $$$x + e = e + x$$$ for any $$$x ∈ S$$$

• $$$id() = F$$$ { $$$1, 0$$$ } because $$$F$$$ contains an identity map given by $$$(a, b) = (1, 0) \to id(x) = ax + b = x$$$

• $$$mapping(F\ l, S\ r) = S$$$ { $$$l_a × r_{sum} + r_{sz} × l_b, r_{sz}$$$ } because the sum will multiply by $$$a$$$ and increase by $$$sz × b$$$

• $$$composition(F\ l, F\ r) = F$$$ { $$$l_a × r_a, l_a × r_b + l_b$$$ } because $$$F$$$ is closed under compositions. With $$$(F\ l, F\ r, S\ x)$$$:

#include <bits/stdc++.h>
#include <atcoder/lazysegtree>
using namespace std;

struct S {
  long long sum;
  int sz;
};
struct F {
  long long a, b;
};
S op(S l, S r) { return S{l.sum + r.sum, l.sz + r.sz}; };
S e() { return S{0, 0}; }
S mapping(F l, S r) { return S{l.a * r.sum + r.sz * l.b, r.sz}; }
F composition(F l, F r) { return F{l.a * r.a, l.a * r.b + l.b}; }
F id() { return F{1, 0}; }

int main() {
  cin.tie(0)->sync_with_stdio(0);
  int n, q;
  cin >> n >> q;
  vector<S> a(n);
  for (int i = 0, x; i < n; i++) {
    cin >> x;
    a[i] = S{x, 1};
  }
  atcoder::lazy_segtree<S, op, e, F, mapping, composition, id> seg(a);
  while (q--) {
    int t, l, r, x;
    cin >> t >> l >> r, --l;
    if (t == 1) {
      cin >> x;
      seg.apply(l, r, F{1, x});
    } else if (t == 2) {
      cin >> x;
      seg.apply(l, r, F{0, x});
    } else {
      cout << seg.prod(l, r).sum << '\n';
    }
  }
}