This documentation is automatically generated by online-judge-tools/verification-helper
#define PROBLEM "https://judge.yosupo.jp/problem/point_set_range_composite"
#include "../../data_structure/segtree.hpp"
#include "../../template/template.hpp"
#include "../../utility/modint.hpp"
using mint = lib::modint998244353;
struct F {
mint a, b;
};
F op(F a, F b) {
return {b.a * a.a, b.b + b.a * a.b};
}
F e() {
return {1, 0};
}
int main() {
int n, q;
std::cin >> n >> q;
std::vector<F> f(n);
rep(i, 0, n) {
ll a, b;
std::cin >> a >> b;
f[i] = {a, b};
}
lib::segtree<F, op, e> seg(f);
while (q--) {
int t;
std::cin >> t;
if (t == 0) {
int p;
ll c, d;
std::cin >> p >> c >> d;
seg.set(p, {c, d});
} else {
int l, r;
ll x;
std::cin >> l >> r >> x;
F prod = seg.prod(l, r);
mint ans = prod.a * x + prod.b;
std::cout << ans.val() << '\n';
}
}
}
#line 1 "test/data_structure/Point_Set_Range_Composite.test.cpp"
#define PROBLEM "https://judge.yosupo.jp/problem/point_set_range_composite"
#line 2 "data_structure/segtree.hpp"
#line 2 "template/template.hpp"
#include <bits/stdc++.h>
#define rep(i, s, n) for (int i = (int)(s); i < (int)(n); i++)
#define rrep(i, s, n) for (int i = (int)(n)-1; i >= (int)(s); i--)
#define all(v) v.begin(), v.end()
using ll = long long;
using ld = long double;
using ull = unsigned long long;
template <typename T> bool chmin(T &a, const T &b) {
if (a <= b) return false;
a = b;
return true;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a >= b) return false;
a = b;
return true;
}
namespace lib {
using namespace std;
} // namespace lib
// using namespace lib;
#line 4 "data_structure/segtree.hpp"
namespace lib {
using namespace std;
template <class S, S (*op)(S, S), S (*e)()> struct segtree {
private:
int n;
int sz;
vector<S> data;
void update(int i) {
data[i] = op(data[2 * i], data[2 * i + 1]);
}
public:
segtree(int n) : segtree(vector<S>(n, e())) {}
segtree(const vector<S> &v) : n((int)v.size()), sz(1) {
while (sz < n) sz *= 2;
data = vector<S>(2 * sz, e());
rep(i, 0, n) {
data[sz + i] = v[i];
}
rrep(i, 1, sz) update(i);
}
void set(int p, S x) {
assert(0 <= p && p < n);
p += sz;
data[p] = x;
while (p > 1) {
p >>= 1;
update(p);
}
}
S get(int p) {
assert(0 <= p && p < n);
return data[p + sz];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= n);
S sml = e(), smr = e();
l += sz;
r += sz;
while (l < r) {
if (l & 1) sml = op(sml, data[l++]);
if (r & 1) smr = op(data[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() {
return data[1];
}
template <class F> int max_right(int l, F f) {
assert(0 <= l && l <= n);
assert(f(e()));
if (l == n) return n;
l += sz;
S sm = e();
do {
while (l % 2 == 0) l >>= 1;
if (!f(op(sm, data[l]))) {
while (l < sz) {
l = 2 * l;
if (f(op(sm, data[l]))) {
sm = op(sm, data[l]);
l++;
}
}
return l - sz;
}
sm = op(sm, data[l]);
l++;
} while ((l & -l) != l);
return n;
}
template <class F> int min_left(int r, F f) {
assert(0 <= r && r <= n);
assert(f(e()));
if (r == 0) return 0;
r += sz;
S sm = e();
do {
r--;
while (r > 1 && (r % 2)) r >>= 1;
if (!f(op(data[r], sm))) {
while (r < sz) {
r = 2 * r + 1;
if (f(op(data[r], sm))) {
sm = op(data[r], sm);
r--;
}
}
return r + 1 - sz;
}
sm = op(data[r], sm);
} while ((r & -r) != r);
return 0;
}
};
} // namespace lib
#line 2 "utility/modint.hpp"
#line 4 "utility/modint.hpp"
namespace lib {
template <ll m> struct modint {
using mint = modint;
ll a;
modint(ll x = 0) : a((x % m + m) % m) {}
static constexpr ll mod() {
return m;
}
ll val() const {
return a;
}
ll& val() {
return a;
}
mint pow(ll n) const {
mint res = 1;
mint x = a;
while (n) {
if (n & 1) res *= x;
x *= x;
n >>= 1;
}
return res;
}
mint inv() const {
return pow(m - 2);
}
mint& operator+=(const mint rhs) {
a += rhs.a;
if (a >= m) a -= m;
return *this;
}
mint& operator-=(const mint rhs) {
if (a < rhs.a) a += m;
a -= rhs.a;
return *this;
}
mint& operator*=(const mint rhs) {
a = a * rhs.a % m;
return *this;
}
mint& operator/=(mint rhs) {
*this *= rhs.inv();
return *this;
}
friend mint operator+(const mint& lhs, const mint& rhs) {
return mint(lhs) += rhs;
}
friend mint operator-(const mint& lhs, const mint& rhs) {
return mint(lhs) -= rhs;
}
friend mint operator*(const mint& lhs, const mint& rhs) {
return mint(lhs) *= rhs;
}
friend mint operator/(const mint& lhs, const mint& rhs) {
return mint(lhs) /= rhs;
}
friend bool operator==(const modint &lhs, const modint &rhs) {
return lhs.a == rhs.a;
}
friend bool operator!=(const modint &lhs, const modint &rhs) {
return !(lhs == rhs);
}
mint operator+() const {
return *this;
}
mint operator-() const {
return mint() - *this;
}
};
using modint998244353 = modint<998244353>;
using modint1000000007 = modint<1'000'000'007>;
} // namespace lib
#line 6 "test/data_structure/Point_Set_Range_Composite.test.cpp"
using mint = lib::modint998244353;
struct F {
mint a, b;
};
F op(F a, F b) {
return {b.a * a.a, b.b + b.a * a.b};
}
F e() {
return {1, 0};
}
int main() {
int n, q;
std::cin >> n >> q;
std::vector<F> f(n);
rep(i, 0, n) {
ll a, b;
std::cin >> a >> b;
f[i] = {a, b};
}
lib::segtree<F, op, e> seg(f);
while (q--) {
int t;
std::cin >> t;
if (t == 0) {
int p;
ll c, d;
std::cin >> p >> c >> d;
seg.set(p, {c, d});
} else {
int l, r;
ll x;
std::cin >> l >> r >> x;
F prod = seg.prod(l, r);
mint ans = prod.a * x + prod.b;
std::cout << ans.val() << '\n';
}
}
}