//#include "testlib.h"
//#include <spoj.h>

#include <iostream>
#include <stdio.h>
#include <vector>
#include <string>
#include <algorithm>
#include <math.h>
#include <assert.h>
#include <time.h>
#include <memory.h>
#include <set>
#include <numeric>
#include <map>
#include <queue>
#include <stack>
#include <bitset>
#include <unordered_map>

using namespace std;

const int max_n = 50000;
const int max_q = 100000;
const int max_t = 1e9;
const int max_sp = 1e9;

int n;

const int MAXH = 1e9;
const long long INF = (long long)2e18;

struct Line {
    long long a, b; // y = ax + b
    Line(long long a = 0, long long b = INF): a(a), b(b) {}
    
    long long eval(int x) {
        return a * x + b;
    }
};

struct Node {
    int l, r;
    Line line;
    Node *left, *right;
    
    Node(int l, int r): l(l), r(r), line(), left(NULL), right(NULL) {}
    
    void pushDown() {
        if (l < r && !left) {
            left = new Node(l, (l + r) >> 1);
            right = new Node(((l + r) >> 1) + 1, r);
        }
    }
    
    void update(Line newLine) {
        pushDown();
        Line A = line, B = newLine;
        if (A.eval(l) < B.eval(l)) swap(A, B);
        if (A.eval(r) >= B.eval(r)) {
            line = B;
        } else if (l != r) {
            int mid = (l + r) >> 1;
            if (A.eval(mid) > B.eval(mid))
                line = B, right->update(A);
            else
                line = A, left->update(B);
        }
    }
    
    long long getMin(int x) {
        long long ans = line.eval(x);
        int mid = (l + r) >> 1;
        if (x <= mid && left)
            ans = min(ans, left->getMin(x));
        if (mid < x && right)
            ans = min(ans, right->getMin(x));
        return ans;
    }
};

long long a[111111], b[111111], pt[111111];

int main() {
    ios::sync_with_stdio(0);
    int q;
    cin >> n >> q;
    assert(1 <= n && n <= max_n);
    assert(1 <= q && q <= max_q);
    
    Node * N = new Node(1, MAXH);
    N->update(Line());
    long long t, tm, sp, ptm = 0;
    int cl;
    while (q --> 0) {
        cin >> t; assert(1 <= t && t <= 2);
        if (t == 1) {
            cin >> tm >> cl >> sp;
            if (n != 5) {
                assert(ptm <= tm && tm <= max_t); ptm = tm;
                assert(1 <= cl && cl <= n);
                assert(1 <= sp && sp <= max_sp);
            }
            cl--;
            
            b[cl] += a[cl] * tm;
            b[cl] -= sp * tm;
            a[cl] = sp;
            
            N->update(Line(-sp, -b[cl]));
        }
        else {
            cin >> tm;
            assert(ptm <= tm && tm <= max_t); ptm = tm;
            cout << -N->getMin((int)tm) << "\n";
        }
    }
    return 0;
}