package main

import "fmt"

type node struct {
	ls, rs   *node
	val, tag int64
	l, r     int64
}

func (s *node) update() {
	s.val = s.ls.val + s.rs.val
}
func (s *node) len() int64 {
	return s.r - s.l + 1
}
func (s *node) push_down() {
	c := s.tag
	s.tag = 0
	s.ls.tag += c
	s.rs.tag += c
	s.ls.val += c * s.ls.len()
	s.rs.val += c * s.rs.len()
}
func (s *node) modify(l, r, x int64) {
	if l == s.l && r == s.r {
		s.tag += x
		s.val += x * s.len()
		return
	}
	s.push_down()
	mid := (s.l + s.r) >> 1
	if r <= mid {
		s.ls.modify(l, r, x)
	} else if l > mid {
		s.rs.modify(l, r, x)
	} else {
		s.ls.modify(l, mid, x)
		s.rs.modify(mid+1, r, x)
	}
	s.update()
}
func (s *node) query(l, r int64) int64 {
	if l == s.l && r == s.r {
		return s.val
	}
	s.push_down()
	mid := (s.l + s.r) >> 1
	if r <= mid {
		return s.ls.query(l, r)
	} else if l > mid {
		return s.rs.query(l, r)
	} else {
		return s.ls.query(l, mid) + s.rs.query(mid+1, r)
	}
}
func build(l, r int64) *node {
	mid := (l + r) >> 1
	ptr := new(node)
	ptr.l, ptr.r, ptr.val, ptr.tag = l, r, 0, 0
	if l != r {
		ptr.ls = build(l, mid)
		ptr.rs = build(mid+1, r)
		ptr.update()
	} else {
		fmt.Scan(&ptr.val)
	}
	return ptr
}
func main() {
	var n, m int64
	fmt.Scan(&n, &m)
	rt := build(1, n)
	var i int64
	for i = 1; i <= m; i++ {
		var opt, l, r, x int64
		fmt.Scan(&opt, &l, &r)
		if opt == 1 {
			fmt.Scan(&x)
			rt.modify(l, r, x)
		} else {
			fmt.Println(rt.query(l, r))
		}
	}
}