#pragma warning (disable : 4996)
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <cassert>
#include <ctime>
#include <iomanip>
#include <queue>

using namespace std;
#define sz size()
#define all(x) x.begin(),x.end()
#define forn(i,n) for (int i = 0; i<int(n); i++)
#define mp make_pair
#define sqr(x) ((x)*(x))
typedef long long ll;
typedef long double ld;
const ll INF = 1e9 + 9;

struct Node{
    ll val, add, relax;
    bool s;
    Node(){
        val = 0; add = 0; relax = 0; s = true;
    }
    Node(ll val, ll add, ll relax, bool s){
        this->val = val;
        this->add = add;
        this->relax = relax;
        this->s = s;
    }
};
vector<Node> tree;
int N;
void init(int n){
    N = n;
    tree.assign(n * 4, Node());
}

ll getVal(int v){
    return max(tree[v].val + tree[v].add, tree[v].relax);
}
void push_all(int v){
    tree[v * 2].val = tree[v * 2 + 1].val = tree[v].val;
    tree[v * 2].add = tree[v * 2 + 1].add = tree[v].add;
    tree[v * 2].relax = tree[v * 2 + 1].relax = tree[v].relax;
    tree[v * 2].s = tree[v * 2 + 1].s = true;
    tree[v].s = false;
    tree[v].val = 0;
    tree[v].add = 0;
    tree[v].relax = 0;
}

void push_add(int v){
    tree[v * 2].add += tree[v].add;
    tree[v * 2 + 1].add += tree[v].add;
    tree[v * 2].relax += tree[v].add;
    tree[v * 2 + 1].relax += tree[v].add;
    tree[v].add = 0;
}

void push_relax(int v){
    tree[v * 2].relax = max(tree[v * 2].relax, tree[v].relax);
    tree[v * 2 + 1].relax = max(tree[v * 2 + 1].relax, tree[v].relax);
    tree[v].relax = 0;
}

//максимизируем в конце...
void set_tree(int v, ll val, int tl, int tr, int l, int r){
    if (l > r)
        return;
    if (l == tl && r == tr){
        tree[v].s = true;
        tree[v].add = tree[v].relax = 0;
        tree[v].val = val;
    }
    else{
        if (tree[v].s)
            push_all(v);
        push_add(v);
        push_relax(v);
        int tm = (tl + tr) >> 1;
        set_tree(v * 2, val, tl, tm, l, min(r, tm));
        set_tree(v * 2 + 1, val, tm + 1, tr, max(l, tm + 1), r);
        tree[v].val = max(getVal(v * 2), getVal(v * 2 + 1));
    }
}

void add_tree(int v, ll val, int tl, int tr, int l, int r){
    if (l > r)
        return;
    if (l == tl && r == tr){
        tree[v].add += val;
        tree[v].relax += val;
    }
    else{
        if (tree[v].s)
            push_all(v);
        int tm = (tl + tr) >> 1;
        add_tree(v * 2, val, tl, tm, l, min(r, tm));
        add_tree(v * 2 + 1, val, tm + 1, tr, max(l, tm + 1), r);
        tree[v].val = max(getVal(v * 2), getVal(v * 2 + 1));
    }
}

void relax_tree(int v, ll val, int tl, int tr, int l, int r){
    if (l > r)
        return;
    if (l == tl && r == tr){
        tree[v].relax = max(tree[v].relax, val);
    }
    else{
        if (tree[v].s)
            push_all(v);
        push_add(v);
        int tm = (tl + tr) >> 1;
        relax_tree(v * 2, val, tl, tm, l, min(r, tm));
        relax_tree(v * 2 + 1, val, tm + 1, tr, max(l, tm + 1), r);
        tree[v].val = max(getVal(v * 2), getVal(v * 2 + 1));
    }
}

ll query_tree(int v, int tl, int tr, int l, int r){
    if (l > r)
        return 0;
    if (l == tl && r == tr){
        return getVal(v);
    }
    else{
        if (tree[v].s)
            return getVal(v);
        int tm = (tl + tr) >> 1;
        ll a = query_tree(v * 2, tl, tm, l, min(r, tm));
        ll b = query_tree(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
        return max(tree[v].add+max(a, b), tree[v].relax);
    }
}

int main(){
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);

    int n, m;
    cin >> n >> m;
    init(n);

    for (int i = 0; i < m; i++){
        string type;
        cin >> type;
        if (type == "set"){
            int ind;
            ll val;
            cin >> ind >> val;
            set_tree(1, val, 0, N - 1, ind, ind);
        }
        else if (type == "segmentset"){
            int l, r;
            ll val;
            cin >> l >> r >> val;
            set_tree(1, val, 0, N - 1, l, r - 1);
        }
        else if (type == "segmentadd"){
            int l, r;
            ll val;
            cin >> l >> r >> val;
            add_tree(1, val, 0, N - 1, l, r - 1);
        }
        else if (type == "segmentrelax"){
            int l, r;
            ll val;
            cin >> l >> r >> val;
            relax_tree(1, val, 0, N - 1, l, r - 1);
        }
        else if (type == "get"){
            int ind;
            cin >> ind;
            cout << query_tree(1, 0, N - 1, ind, ind) << endl;
        }
        else if (type == "segmentmax"){
            int l, r;
            cin >> l >> r;
            cout << query_tree(1, 0, N - 1, l, r - 1) << endl;
        }
    }

    return 0;
}