from sys import stdin,setrecursionlimit#,set_int_max_str_digits
#import pypyjit
#pypyjit.set_param('max_unroll_recursion=-1')
# setrecursionlimit(2000000) # これこどふぉだと無理
# set_int_max_str_digits(200010)
mod = 998244353 
ii = lambda :int(stdin.readline())
mi = lambda :map(int,stdin.readline().split())
li = lambda :list(mi())
gmi = lambda :map(lambda x: int(x) - 1, stdin.readline().split())
gi = lambda :list(map(lambda x: 0 if x == "." else 1,input())) # グリッド入力受け取り
py = lambda :print("Yes")
pn = lambda :print("No")
pf = lambda :print("First") 
ps = lambda :print("Second")
pyn = lambda x: print("Yes") if x else print("No")
vec = [(1,0),(-1,0),(0,-1),(0,1)]
vec1 = [(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1),(0,-1),(1,-1)] #8方向
vec2 = [(1,1),(1,0),(0,-1),(-1,-1),(-1,0),(0,1)] # 六角形グリッド
inf = 10**18
from collections import defaultdict,deque
from heapq import heappop,heappush
# from random import randint
# from itertools import permutations 


# verify https://atcoder.jp/contests/abc339/submissions/56218265

# モノイドがのるやつ
from heapq import merge  
class MergeSortTree1():
    def __init__(self,data,op,e):
        self.n = len(data) 
        self.d = [[] if i < self.n else [data[i-self.n]] for i in range(self.n<<1)] 
        self.op = op
        self.e = e
        # self.Min = min(data)
        # self.Max = max(data)
        for i in reversed(range(self.n)):
            *self.d[i], = merge(self.d[i<<1],self.d[i<<1|1])
        self.d1 = [[x for x in i] for i in self.d]
        for x in self.d1:
            for i in range(1,len(x)):
                x[i] = op(x[i-1],x[i])
            x.append(self.e)
    
    def query(self,l,r,k):
        l += self.n 
        r += self.n 
        ret = self.e 
        ret1 = 0 
        while l < r:
            if l & 1:
                dd = self.d[l] 
                ok = -1 
                ng = len(dd)
                while ng - ok > 1:
                    mid = (ok+ng)>>1
                    if dd[mid] <= k:
                        ok = mid 
                    else:
                        ng = mid                     
                ret = self.op(ret,self.d1[l][ok])
                ret1 += ok+1
                l += 1
            if r & 1:
                r -= 1
                dd = self.d[r] 
                ok = -1 
                ng = len(dd)
                while ng - ok > 1:
                    mid = (ok+ng)>>1 
                    if dd[mid] <= k:
                        ok = mid 
                    else:
                        ng = mid 
                ret = self.op(ret,self.d1[r][ok]) 
                ret1 += ok + 1
            l >>= 1 
            r >>= 1
        return ret,ret1  
    

# verify https://judge.yosupo.jp/submission/225318

from heapq import merge  
class MergeSortTree():
    def __init__(self,data):
        self.n = len(data) 
        self.d = [[] if i < self.n else [data[i-self.n]] for i in range(self.n<<1)]
        self.Min = min(data)
        self.Max = max(data)
        for i in reversed(range(self.n)):
            *self.d[i], = merge(self.d[i<<1],self.d[i<<1|1])
    
    # count elements A_i s.t. A_i <= k for i in [l, r)
    def query(self,l,r,k):
        l += self.n 
        r += self.n 
        ret = 0 
        while l < r:
            if l & 1:
                dd = self.d[l] 
                ok = -1 
                ng = len(dd)
                while ng - ok > 1:
                    mid = (ok+ng)>>1
                    if dd[mid] <= k:
                        ok = mid 
                    else:
                        ng = mid                     
                ret += ok + 1 
                l += 1
            if r & 1:
                r -= 1
                dd = self.d[r] 
                ok = -1 
                ng = len(dd)
                while ng - ok > 1:
                    mid = (ok+ng)>>1 
                    if dd[mid] <= k:
                        ok = mid 
                    else:
                        ng = mid 
                ret += ok + 1 
            l >>= 1 
            r >>= 1
        return ret  

    # count elements A_i s.t. a <= A_i < b for i in [l, r)    
    def query1(self,l,r,a,b):
        l += self.n 
        r += self.n 
        ret = 0 
        while l < r:
            if l & 1:
                dd = self.d[l] 
                ok = -1 
                ng = len(dd)
                while ng - ok > 1:
                    mid = (ok+ng)>>1
                    if dd[mid] <= a-1:
                        ok = mid 
                    else:
                        ng = mid
                ret -= ok
                ng = len(dd)
                while ng - ok > 1:
                    mid = (ok+ng)>>1
                    if dd[mid] <= b-1:
                        ok = mid 
                    else:
                        ng = mid
                ret += ok 
                l += 1
            if r & 1:
                r -= 1
                dd = self.d[r] 
                ok = -1 
                ng = len(dd)
                while ng - ok > 1:
                    mid = (ok+ng)>>1
                    if dd[mid] <= a-1:
                        ok = mid 
                    else:
                        ng = mid
                ret -= ok
                ng = len(dd)
                while ng - ok > 1:
                    mid = (ok+ng)>>1
                    if dd[mid] <= b-1:
                        ok = mid 
                    else:
                        ng = mid
                ret += ok
            l >>= 1 
            r >>= 1
        return ret 
    
    def kth_smallest(self,l,r,k):
        L = self.Min - 1
        R = self.Max + 1 
        data = [] 
        l += self.n 
        r += self.n  
        while l < r:
            if l & 1:
                data.append(l)
                l += 1
            if r & 1:
                r -= 1
                data.append(r)
            l >>= 1 
            r >>= 1     
        pre_ok = [-1]*len(data) 
        pre_ng = [len(self.d[i]) for i in data]    
        pre_d = [-1]*len(data)
        flag = 1 
        while R - L > 1:
            mid1 = (L+R)>>1 
            cnt = 0 
            for i,x in enumerate(data):
                dd = self.d[x] 
                if flag:
                    ok = pre_d[i] 
                    pre_ok[i] = ok 
                    ng = pre_ng[i] 
                else:
                    ok = pre_ok[i] 
                    ng = pre_d[i] + 1
                    pre_ng[i] = ng 
                while ng - ok > 1:
                    mid = (ok+ng)>>1
                    if dd[mid] <= mid1:
                        ok = mid 
                    else:
                        ng = mid  
                pre_d[i] = ok                   
                cnt += ok + 1  
            if cnt < k:
                L = mid1 
                flag = 1 
            else:
                R = mid1 
                flag = 0
        return L + 1  


n,q = mi() 
a = li()


def add(x,y):
    return x + y 
e = 0 
mt1 = MergeSortTree1(a,add,e)

for _ in range(q):
    l,r,x = mi()
    l -= 1 
    k,cnt = mt1.query(l,r,x)
    tmp = (r-l-cnt)*x 
    tmp += k
    print(tmp)