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

int main() {
    int n, q;
    cin >> n >> q;
    vector<long long> a(n);
    long long current_sum = 0;
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        current_sum += a[i];
    }
    cout << current_sum << endl;
    while (q--) {
        long long l, r, x;
        cin >> l >> r >> x;
        current_sum = 0;
        for (int i = 0; i < n; i++) {
            if (a[i] >= l && a[i] <= r) {
                a[i] = x;
            }
            current_sum += a[i];
        }
        cout << current_sum << endl;
    }
    return 0;
}

import sys

def solve():
    input = sys.stdin.read().split()
    n = int(input[0])
    q = int(input[1])
    a = list(map(int, input[2:2+n]))

    current_sum = sum(a)
    print(current_sum)

    ptr = 2 + n
    for _ in range(q):
        l = int(input[ptr])
        r = int(input[ptr+1])
        x = int(input[ptr+2])
        ptr += 3

        current_sum = 0
        for i in range(n):
            if l <= a[i] <= r:
                a[i] = x
            current_sum += a[i]
        print(current_sum)

solve()

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

int main() {
    // Tối ưu tốc độ nhập xuất
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, q;
    cin >> n >> q;

    map<long long, long long> countByValue;
    long long totalSum = 0;

    // Đếm số lần xuất hiện của từng giá trị ban đầu
    for (int i = 0; i < n; i++) {
        long long value;
        cin >> value;
        countByValue[value]++;
        totalSum += value;
    }

    // In tổng ban đầu
    cout << totalSum << '\n';

    for (int i = 0; i < q; i++) {
        long long l, r, x;
        cin >> l >> r >> x;

        // Tìm phần tử đầu tiên có giá trị >= l
        auto it = countByValue.lower_bound(l);
        long long movedCount = 0;
        vector<long long> valuesToErase;

        // Duyệt qua các phần tử có giá trị <= r
        while (it != countByValue.end() && it->first <= r) {
            long long val = it->first;
            long long cnt = it->second;

            movedCount += cnt;
            totalSum -= val * cnt; // Trừ giá trị cũ khỏi tổng
            valuesToErase.push_back(val);
            it++;
        }

        // Xóa các giá trị đã xử lý khỏi map
        for (long long v : valuesToErase) {
            countByValue.erase(v);
        }

        // Thêm giá trị mới x vào map
        if (movedCount > 0) {
            countByValue[x] += movedCount;
            totalSum += x * movedCount; // Cộng giá trị mới vào tổng
        }

        cout << totalSum << '\n';
    }

    return 0;
}

import sys
from bisect import bisect_left, bisect_right

def solve():
    # Đọc toàn bộ dữ liệu để xử lý nhanh hơn
    input_data = sys.stdin.read().split()
    if not input_data:
        return

    n = int(input_data[0])
    q = int(input_data[1])

    count_by_value = {}
    total_sum = 0

    # Đếm số lần xuất hiện ban đầu
    for i in range(n):
        val = int(input_data[2 + i])
        count_by_value[val] = count_by_value.get(val, 0) + 1
        total_sum += val

    print(total_sum)

    # Sắp xếp các key để tìm kiếm nhị phân
    sorted_keys = sorted(count_by_value.keys())

    ptr = 2 + n
    for _ in range(q):
        l = int(input_data[ptr])
        r = int(input_data[ptr+1])
        x = int(input_data[ptr+2])
        ptr += 3

        # Tìm các giá trị trong đoạn [l, r]
        idx_l = bisect_left(sorted_keys, l)
        idx_r = bisect_right(sorted_keys, r)

        moved_count = 0
        # Duyệt các giá trị cần xóa
        for i in range(idx_l, idx_r):
            val = sorted_keys[i]
            cnt = count_by_value.pop(val)
            moved_count += cnt
            total_sum -= val * cnt

        # Cập nhật danh sách key và map
        if moved_count > 0:
            total_sum += x * moved_count
            count_by_value[x] = count_by_value.get(x, 0) + moved_count

        # Chỉ sắp xếp lại khi có sự thay đổi thực sự để đảm bảo hiệu năng
        if idx_l < idx_r:
            sorted_keys = sorted(count_by_value.keys())

        print(total_sum)

if __name__ == "__main__":
    solve()