package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

var N int = 1000005
var tree []Node = make([]Node, 4*N)
var offset []int64 = make([]int64, N)
var col []int = make([]int, N)
var addv []int64 = make([]int64, N)

type Node struct {
	lazy_add   int64
	lazy_color int
	uniform    int
}

func build(node, tl, tr int) {
	tree[node] = Node{0, -1, 1}
	if tl == tr {
		col[tl] = 1
		offset[tl] = 0
		tree[node].uniform = 1
		return
	}
	mid := (tl + tr) / 2
	build(2*node, tl, mid)
	build(2*node+1, mid+1, tr)
}

func propagate(node, tl, tr int) {
	if tree[node].lazy_add != 0 || tree[node].lazy_color != -1 {
		if tl != tr {
			tree[2*node].lazy_add += tree[node].lazy_add
			if tree[node].lazy_color != -1 {
				tree[2*node].lazy_color = tree[node].lazy_color
				tree[2*node].uniform = tree[node].lazy_color
			}
			tree[2*node+1].lazy_add += tree[node].lazy_add
			if tree[node].lazy_color != -1 {
				tree[2*node+1].lazy_color = tree[node].lazy_color
				tree[2*node+1].uniform = tree[node].lazy_color
			}
		} else {
			offset[tl] += tree[node].lazy_add
			if tree[node].lazy_color != -1 {
				col[tl] = tree[node].lazy_color
			}
			tree[node].uniform = col[tl]
		}
		tree[node].lazy_add = 0
		tree[node].lazy_color = -1
	}
	if tl != tr {
		l := tree[2*node].uniform
		rr := tree[2*node+1].uniform
		if l == rr && l != -1 {
			tree[node].uniform = l
		} else {
			tree[node].uniform = -1
		}
	} else {
		tree[node].uniform = col[tl]
	}
}

func update(node, tl, tr, l, r, new_c int) {
	propagate(node, tl, tr)
	if tl > r || tr < l {
		return
	}
	if l <= tl && tr <= r {
		if tree[node].uniform != -1 {
			old_c := tree[node].uniform
			tree[node].lazy_add += addv[old_c] - addv[new_c]
			tree[node].lazy_color = new_c
			tree[node].uniform = new_c
			return
		}
	}
	mid := (tl + tr) / 2
	update(2*node, tl, mid, l, r, new_c)
	update(2*node+1, mid+1, tr, l, r, new_c)
	lv := tree[2*node].uniform
	rv := tree[2*node+1].uniform
	if lv == rv && lv != -1 {
		tree[node].uniform = lv
	} else {
		tree[node].uniform = -1
	}
}

func get(pos int, node, tl, tr int) int64 {
	propagate(node, tl, tr)
	if tl == tr {
		return offset[tl] + addv[col[tl]]
	}
	mid := (tl + tr) / 2
	if pos <= mid {
		return get(pos, 2*node, tl, mid)
	} else {
		return get(pos, 2*node+1, mid+1, tr)
	}
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	line, _ := reader.ReadString('\n')
	parts := strings.Fields(line)
	n, _ := strconv.Atoi(parts[0])
	q, _ := strconv.Atoi(parts[1])
	build(1, 1, n)
	var answers []string
	for i := 0; i < q; i++ {
		line, _ = reader.ReadString('\n')
		parts = strings.Fields(line)
		typ := parts[0]
		if typ == "Color" {
			l, _ := strconv.Atoi(parts[1])
			r, _ := strconv.Atoi(parts[2])
			c, _ := strconv.Atoi(parts[3])
			update(1, 1, n, l, r, c)
		} else if typ == "Add" {
			c, _ := strconv.Atoi(parts[1])
			x, _ := strconv.ParseInt(parts[2], 10, 64)
			addv[c] += x
		} else if typ == "Query" {
			ii, _ := strconv.Atoi(parts[1])
			val := get(ii, 1, 1, n)
			answers = append(answers, fmt.Sprintln(val))
		}
	}
	for _, ans := range answers {
		fmt.Print(ans)
	}
}