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

const int MAXN = 200005;
long long ans[MAXN]; // ans[i] là giá lớn nhất tại vị trí i

struct Item {
    int s, e;
    long long v, d;
};

int main() {
    int n, m;
    cin >> n >> m;
    vector<Item> items(m);
    for (int i = 0; i < m; ++i) {
        cin >> items[i].s >> items[i].e >> items[i].v >> items[i].d;
    }

    // Khởi tạo ans về 0
    fill(ans, ans + n + 1, 0);

    // Duyệt qua từng loại trang sức và cập nhật giá cho từng vị trí trong đoạn [s, e]
    for (const auto& it : items) {
        for (int pos = it.s; pos <= it.e; ++pos) {
            long long price = it.v + (long long)(pos - it.s) * it.d;
            ans[pos] = max(ans[pos], price);
        }
    }

    for (int i = 1; i <= n; ++i) {
        cout << ans[i] << "\n";
    }
    return 0;
}

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

typedef long long ll;
const int N = 2e5 + 8;
int n, m;

// Cấu trúc Line: f(x) = a*x + b
struct Line {
    ll a, b;
    Line(ll _a = 0, ll _b = 0) : a(_a), b(_b) {}
    ll operator()(int x) { return a * x + b; }
} seg[N << 2];

// Hàm cập nhật Line vào 1 node của Segment Tree (tương tự Li Chao Tree)
// Nếu node hiện tại chưa có Line (a=0, b=0) thì gán trực tiếp.
// Nếu đã có, so sánh giá trị tại điểm giữa (mid).
// Nếu Line mới tốt hơn tại mid, đổi chỗ Line cũ và Line mới (swap).
// Sau đó Line bị loại (line) sẽ được đẩy xuống con sao cho nó thắng (nếu có).
void upd(int u, int l, int r, Line line) {
    if (l == r) {
        if (seg[u](l) < line(l))
            seg[u] = line;
        return;
    }
    int m = (l + r) >> 1;

    // So sánh độ dốc: Nếu line mới dốc hơn (a lớn hơn), nó có cơ hội thắng ở bên phải.
    // Tuy nhiên, logic Li Chao là ưu tiên Line thắng ở mid.
    // Logic thường thấy: Nếu line mới thắng ở mid, swap.
    // Code mẫu sử dụng một biến thể:
    if (seg[u].a > line.a) // Nếu line cũ dốc hơn line mới
        swap(seg[u], line); // Gán line mới vào root (để đảm bảo root có dốc nhỏ hơn?)

    // Kiểm tra xem line mới có thắng ở mid không?
    if (seg[u](m) < line(m)) {
        swap(seg[u], line); // Root giữ line mới (vì nó tốt hơn ở mid)
        upd(u << 1, l, m, line); // Line cũ được đẩy xuống trái
    } else {
        upd(u << 1 | 1, m + 1, r, line); // Line cũ được đẩy xuống phải
    }
}

// Phân tích đoạn [a, b] của trang sức và thêm vào Segment Tree
void decomposition(int u, int l, int r, int a, int b, int v, int d) {
    if (a <= l && r <= b) {
        // Tính Line f(x) = d*x + (v - d*a) để giá tại a là v
        upd(u, l, r, Line(d, v - (ll)a * d));
        return;
    }
    int m = (l + r) >> 1;
    if (m >= a)
        decomposition(u << 1, l, m, a, b, v, d);
    if (b > m)
        decomposition(u << 1 | 1, m + 1, r, a, b, v, d);
}

ll get(int u, int l, int r, int x) {
    ll res = seg[u](x);
    if (l == r) return res;
    int m = (l + r) >> 1;
    if (x <= m)
        return max(res, get(u << 1, l, m, x));
    else
        return max(res, get(u << 1 | 1, m + 1, r, x));
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> n >> m;
    for (int i = 0; i < m; ++i) {
        int s, e;
        ll v, d;
        cin >> s >> e >> v >> d;
        decomposition(1, 1, n, s, e, v, d);
    }
    for (int i = 1; i <= n; ++i) {
        cout << get(1, 1, n, i) << "\n";
    }
    return 0;
}

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

typedef long long ll;
const int MAXN = 200005;

struct Line {
    ll a, b;
    Line(ll _a = 0, ll _b = 0) : a(_a), b(_b) {}
    ll get(ll x) { return a * x + b; }
};

struct Node {
    Line line;
    Node *left = nullptr, *right = nullptr;
    Node() : line(Line(0, 0)) {}
};

Node* root[MAXN]; // Mảng các cây, mỗi vị trí có thể có một cây (tối ưu bộ nhớ)
// Hoặc dùng map<int, Node*> root; nếu sparse

// Thêm line vào cây bắt đầu từ node cur, trên đoạn [l, r]
void add_line(Node*& cur, int l, int r, Line newLine) {
    if (!cur) cur = new Node();

    int m = l + (r - l) / 2;
    bool mid = newLine.get(m) > cur->line.get(m);

    if (mid) swap(cur->line, newLine);

    if (l == r) return;

    if (newLine.a > cur->line.a) { // newLine tăng nhanh hơn (slope steeper)
        add_line(cur->right, m + 1, r, newLine);
    } else {
        add_line(cur->left, l, m, newLine);
    }
}

ll query(Node* cur, int l, int r, int x) {
    if (!cur) return 0;
    int m = l + (r - l) / 2;
    ll val = cur->line.get(x);
    if (l == r) return val;
    if (x <= m) return max(val, query(cur->left, l, m, x));
    else return max(val, query(cur->right, m + 1, r, x));
}

// Cấu trúc để xử lý Offline Sweep Line
struct Event {
    int x;
    int type; // 0 = add, 1 = query, 2 = remove (nếu cần)
    int id; 
    Line l;
    // Sort: x tăng, query trước add sau? 
    // Logic: Để query tại x, cần add line tại x (hoặc trước đó).
    // Line áp dụng từ s -> e. Nên add tại s, remove tại e+1.
    // Nếu chỉ add tại s, line vẫn còn trong cây sau e, sai.
    // Cần xử lý remove?
    // Li Chao Tree không hỗ trợ remove tốt.
    // Thay đổi strategy: Duyệt x từ 1 đến n.
    // Khi gặp start s, thêm line vào list active.
    // Khi gặp end e, xóa line khỏi list active.
    // Li Chao Tree không xóa được.
    // Giải pháp: Dùng Persistent Li Chao Tree.
    // Hoặc: Dùng Segment Tree of Li Chao Tree (Solution 1).
    // Giả sử dùng Persistent Li Chao Tree (cập nhật phiên bản).
    // Code dưới đây minh họa Persistent Li Chao Tree (mang line từ phiên bản trước).
};

// Persistent Li Chao Tree
void add_line_persistent(Node*& cur, Node* old, int l, int r, Line newLine) {
    cur = new Node(); // Tạo node mới
    if (old) cur->left = old->left, cur->right = old->right, cur->line = old->line;

    int m = l + (r - l) / 2;
    bool mid = newLine.get(m) > cur->line.get(m);

    if (mid) swap(cur->line, newLine);

    if (l == r) return;

    if (newLine.a > cur->line.a) {
        add_line_persistent(cur->right, old ? old->right : nullptr, m + 1, r, newLine);
    } else {
        add_line_persistent(cur->left, old ? old->left : nullptr, l, m, newLine);
    }
}

vector<int> starts[MAXN]; // starts[x] chứa các index line bắt đầu tại x
vector<Line> all_lines;
Node* version[MAXN]; // version[i] là root của cây tại thời điểm i

int main() {
    int n, m;
    cin >> n >> m;
    all_lines.reserve(m);
    for(int i=0; i<m; ++i) {
        int s, e; ll v, d;
        cin >> s >> e >> v >> d;
        // Line: f(x) = d*x + (v - d*s)
        Line l(d, v - (ll)d * s);
        all_lines.push_back(l);
        starts[s].push_back(i);
        // Persistent không tự động remove.
        // Strategy: Sweep line từ 1 -> n.
        // version[i] = version[i-1] + các line bắt đầu tại i - các line kết thúc tại i-1.
        // Nhưng Persistent không xóa.
        // Thay vào đó: Dùng Segment Tree of Li Chao Tree là chuẩn nhất.
        // Hoặc: Duyệt 1->n, duy trì một List các line active.
        // Nếu List nhỏ thì OK, nhưng List có thể to.
    }
    // Code này chỉ minh họa ý tưởng Persistent, không hoàn chỉnh để xử lý remove.
    return 0;
}