#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
typedef long long ll;
typedef long double ld;
const ll INF = 1e9 + 9;

vector<ll> tree;
vector<bool> isSet;
int N;
void init(int n){
    tree.assign(n * 4,0);
    isSet.assign(n * 4, true);
    N = n;
}

void push(int v){
    tree[v * 2] = tree[v * 2 + 1] = tree[v];
    tree[v] = 0;
    isSet[v * 2] = isSet[v * 2 + 1] = true;
    isSet[v] = false;
}

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] = val;
        isSet[v] = true;
    }
    else{
        if (isSet[v])
            push(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] = max(tree[v * 2], tree[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] += val;
    }
    else{
        if (isSet[v])
            push(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] = max(tree[v * 2], tree[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] = max(tree[v], val);
    }
    else{
        if (isSet[v])
            push(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] = max(tree[v * 2], tree[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 tree[v];
    }
    else{
        if (isSet[v]){
            return tree[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(tm + 1, l), r);
        return max(a, b);
    }
}

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;
}