#include <iostream>
#include <vector>
#include <map>
#include <utility>
#include <atcoder/lazysegtree>

int64_t gcd(int64_t a, int64_t b) {
    if (a < b) return gcd(b, a);
    if (b == 0) return a;
    return gcd(b, a % b);
}

struct S {
    int64_t sum = 0, max = 0;
    int count = 0;
};

S op(S a, S b) {
    return {a.sum + b.sum, a.max > b.max ? a.max : b.max, a.count + b.count};
}

S e() {
    return {};
}

S mapping(int64_t f, S x) {
    if (f < 0) return x;
    return {f * x.count, f, x.count};
}

int64_t composition(int64_t f, int64_t g) {
    if (f < 0) return g;
    return f;
}

int64_t id() {
    return -1;
}

int main() {
    int N, Q;
    std::cin >> N >> Q;
    std::vector<S> A(N);
    for (S &a : A) std::cin >> a.sum, a.max = a.sum, a.count = 1;

    atcoder::lazy_segtree<S, op, e, int64_t, mapping, composition, id> seg(A);

    std::map<int, std::pair<int, int64_t>> intervals;
    int i = 0;
    while (i < N) {
        int j = i + 1;
        while (j < N && A[i].sum == A[j].sum) j++;
        intervals[i] = {j, A[i].sum};
        i = j;
    }

    while (Q--) {
        int t, l, r;
        std::cin >> t >> l >> r;
        l--;
        if (t == 1) {
            int64_t y;
            std::cin >> y;
            seg.apply(l, r, y);
            auto start = intervals.lower_bound(l);
            if (start != intervals.begin() && l < std::prev(start)->second.first) {
                if (std::prev(start)->second.first > r) {
                    start = intervals.emplace(r, std::prev(start)->second).first;
                }
                std::prev(start)->second.first = l;
            }
            auto stop = intervals.lower_bound(r);
            if (stop != intervals.begin() && r < std::prev(stop)->second.first) {
                stop = intervals.emplace(r, std::prev(stop)->second).first;
            }
            intervals.erase(start, stop);
            intervals[l] = {r, y};
        } else if (t == 2) {
            int64_t x;
            std::cin >> x;
            auto start = intervals.lower_bound(l);
            if (start != intervals.begin() && l < std::prev(start)->second.first) {
                if (std::prev(start)->second.first > r) {
                    start = intervals.emplace(r, std::prev(start)->second).first;
                }
                start = intervals.emplace(l, std::prev(start)->second).first;
                std::prev(start)->second.first = l;
            }
            auto stop = intervals.lower_bound(r);
            if (stop != intervals.begin() && r < std::prev(stop)->second.first) {
                stop = intervals.emplace(r, std::prev(stop)->second).first;
                std::prev(stop)->second.first = r;
            }
            auto iter = start;
            while (iter != stop) {
                int nl = iter->first;
                auto &[nr, val] = iter->second;
                val = gcd(val, x);
                seg.apply(nl, nr, val);
                if (iter != intervals.begin() && nl == std::prev(iter)->second.first && val == std::prev(iter)->second.second) {
                    std::prev(iter)->second.first = nr;
                    iter = intervals.erase(iter);
                } else iter++;
            }
        } else if (t == 3) {
            std::cout << seg.prod(l, r).max << std::endl;
        } else {
            std::cout << seg.prod(l, r).sum << std::endl;
        }
    }
}