package main

import (
	"bufio"
	"fmt"
	"os"
)

const INF int64 = 1e15
const MAX int = 100005

var (
	max1_p, max2_p, lazy_p []int64
	max1_n, max2_n, lazy_n []int64
	sum_p4, sum_n4         []int64

	cnt_max1_p, cnt_max1_n             []int
	cnt_empty, cnt_p_only, cnt_n_only, cnt4 []int
	cnt4_max1_p, cnt4_max1_n           []int
)

func initTree() {
	size := 4 * MAX
	max1_p = make([]int64, size)
	max2_p = make([]int64, size)
	lazy_p = make([]int64, size)
	max1_n = make([]int64, size)
	max2_n = make([]int64, size)
	lazy_n = make([]int64, size)
	sum_p4 = make([]int64, size)
	sum_n4 = make([]int64, size)

	cnt_max1_p = make([]int, size)
	cnt_max1_n = make([]int, size)
	cnt_empty = make([]int, size)
	cnt_p_only = make([]int, size)
	cnt_n_only = make([]int, size)
	cnt4 = make([]int, size)
	cnt4_max1_p = make([]int, size)
	cnt4_max1_n = make([]int, size)
}

func max(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}

func build(u, l, r int) {
	max1_p[u] = INF
	max2_p[u] = -INF
	cnt_max1_p[u] = r - l + 1
	lazy_p[u] = INF

	max1_n[u] = INF
	max2_n[u] = -INF
	cnt_max1_n[u] = r - l + 1
	lazy_n[u] = INF

	cnt_empty[u] = r - l + 1
	cnt_p_only[u] = 0
	cnt_n_only[u] = 0
	cnt4[u] = 0

	sum_p4[u] = 0
	sum_n4[u] = 0
	cnt4_max1_p[u] = 0
	cnt4_max1_n[u] = 0

	if l == r {
		return
	}
	mid := (l + r) / 2
	build(u*2, l, mid)
	build(u*2+1, mid+1, r)
}

func apply_p(u int, v int64) {
	if v >= max1_p[u] {
		return
	}
	sum_p4[u] -= (max1_p[u] - v) * int64(cnt4_max1_p[u])
	if max1_p[u] == INF {
		cnt_p_only[u] += cnt_empty[u]
		cnt_empty[u] = 0
	}
	max1_p[u] = v
	lazy_p[u] = v
}

func apply_n(u int, v int64) {
	if v >= max1_n[u] {
		return
	}
	sum_n4[u] -= (max1_n[u] - v) * int64(cnt4_max1_n[u])
	if max1_n[u] == INF {
		cnt_n_only[u] += cnt_empty[u]
		cnt_empty[u] = 0
	}
	max1_n[u] = v
	lazy_n[u] = v
}

func push(u int) {
	if lazy_p[u] != INF {
		apply_p(u*2, lazy_p[u])
		apply_p(u*2+1, lazy_p[u])
		lazy_p[u] = INF
	}
	if lazy_n[u] != INF {
		apply_n(u*2, lazy_n[u])
		apply_n(u*2+1, lazy_n[u])
		lazy_n[u] = INF
	}
}

func pull(u int) {
	lc := u * 2
	rc := u * 2 + 1

	if max1_p[lc] > max1_p[rc] {
		max1_p[u] = max1_p[lc]
		max2_p[u] = max(max2_p[lc], max1_p[rc])
		cnt_max1_p[u] = cnt_max1_p[lc]
	} else if max1_p[lc] < max1_p[rc] {
		max1_p[u] = max1_p[rc]
		max2_p[u] = max(max1_p[lc], max2_p[rc])
		cnt_max1_p[u] = cnt_max1_p[rc]
	} else {
		max1_p[u] = max1_p[lc]
		max2_p[u] = max(max2_p[lc], max2_p[rc])
		cnt_max1_p[u] = cnt_max1_p[lc] + cnt_max1_p[rc]
	}

	if max1_n[lc] > max1_n[rc] {
		max1_n[u] = max1_n[lc]
		max2_n[u] = max(max2_n[lc], max1_n[rc])
		cnt_max1_n[u] = cnt_max1_n[lc]
	} else if max1_n[lc] < max1_n[rc] {
		max1_n[u] = max1_n[rc]
		max2_n[u] = max(max1_n[lc], max2_n[rc])
		cnt_max1_n[u] = cnt_max1_n[rc]
	} else {
		max1_n[u] = max1_n[lc]
		max2_n[u] = max(max2_n[lc], max2_n[rc])
		cnt_max1_n[u] = cnt_max1_n[lc] + cnt_max1_n[rc]
	}

	cnt_empty[u] = cnt_empty[lc] + cnt_empty[rc]
	cnt_p_only[u] = cnt_p_only[lc] + cnt_p_only[rc]
	cnt_n_only[u] = cnt_n_only[lc] + cnt_n_only[rc]
	cnt4[u] = cnt4[lc] + cnt4[rc]

	sum_p4[u] = sum_p4[lc] + sum_p4[rc]
	sum_n4[u] = sum_n4[lc] + sum_n4[rc]

	cnt4_max1_p[u] = 0
	if max1_p[u] == max1_p[lc] {
		cnt4_max1_p[u] += cnt4_max1_p[lc]
	}
	if max1_p[u] == max1_p[rc] {
		cnt4_max1_p[u] += cnt4_max1_p[rc]
	}

	cnt4_max1_n[u] = 0
	if max1_n[u] == max1_n[lc] {
		cnt4_max1_n[u] += cnt4_max1_n[lc]
	}
	if max1_n[u] == max1_n[rc] {
		cnt4_max1_n[u] += cnt4_max1_n[rc]
	}
}

func update_p(u, l, r, ql, qr int, v int64) {
	if l > qr || r < ql || v >= max1_p[u] {
		return
	}
	if ql <= l && r <= qr && cnt_n_only[u] == 0 && v > max2_p[u] {
		apply_p(u, v)
		return
	}
	if l == r {
		sum_p4[u] = v
		sum_n4[u] = max1_n[u]
		cnt4[u] = 1
		cnt_n_only[u] = 0
		cnt4_max1_p[u] = 1
		cnt4_max1_n[u] = 1
		max1_p[u] = v
		return
	}
	push(u)
	mid := (l + r) / 2
	update_p(u*2, l, mid, ql, qr, v)
	update_p(u*2+1, mid+1, r, ql, qr, v)
	pull(u)
}

func update_n(u, l, r, ql, qr int, v int64) {
	if l > qr || r < ql || v >= max1_n[u] {
		return
	}
	if ql <= l && r <= qr && cnt_p_only[u] == 0 && v > max2_n[u] {
		apply_n(u, v)
		return
	}
	if l == r {
		sum_p4[u] = max1_p[u]
		sum_n4[u] = v
		cnt4[u] = 1
		cnt_p_only[u] = 0
		cnt4_max1_p[u] = 1
		cnt4_max1_n[u] = 1
		max1_n[u] = v
		return
	}
	push(u)
	mid := (l + r) / 2
	update_n(u*2, l, mid, ql, qr, v)
	update_n(u*2+1, mid+1, r, ql, qr, v)
	pull(u)
}

func query(u, l, r, ql, qr int) int64 {
	if l > qr || r < ql {
		return 0
	}
	if ql <= l && r <= qr {
		return sum_p4[u] + sum_n4[u]
	}
	push(u)
	mid := (l + r) / 2
	return query(u*2, l, mid, ql, qr) + query(u*2+1, mid+1, r, ql, qr)
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 1024*1024), 1024*1024*10)

	scanInt := func() int {
		scanner.Scan()
		res := 0
		sign := 1
		for _, b := range scanner.Bytes() {
			if b == '-' {
				sign = -1
			} else {
				res = res*10 + int(b-'0')
			}
		}
		return res * sign
	}

	if !scanner.Scan() {
		return
	}
	qStr := scanner.Bytes()
	q := 0
	for _, b := range qStr {
		q = q*10 + int(b-'0')
	}

	initTree()
	build(1, 1, MAX-1)

	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	for i := 0; i < q; i++ {
		typ := scanInt()
		if typ == 1 {
			l := scanInt()
			r := scanInt()
			k := int64(scanInt())
			if k > 0 {
				update_p(1, 1, MAX-1, l, r-1, k)
			} else {
				update_n(1, 1, MAX-1, l, r-1, -k)
			}
		} else {
			l := scanInt()
			r := scanInt()
			ans := query(1, 1, MAX-1, l, r-1)
			fmt.Fprintf(writer, "%d\n", ans)
		}
	}
}