import sys

# for line in sys.stdin:
#     a = line.split()
#     print(int(a[0]) + int(a[1]))
def func1():
    nm= list( map(int,input().split()))
    n=nm[0]
    m=nm[1]
    nums=list(map(int,input().split()))
    for i in range(m):
        cmd=list(map(int,input().split()))
        l=cmd[0]
        r=cmd[1]
        k=cmd[2]
        #print(nums)
        for index in range(l-1,r):
            nums[index]+=k
    #print(nums)
    ret =str(nums[0])
    for i in range(1,len(nums)):
        ret=ret+" "+str(nums[i])
    print(ret)
#func1()

def func2():
    nm= list( map(int,input().split()))
    n=nm[0]
    m=nm[1]
    nums=list(map(int,input().split()))
    # 创建差分数组
    #print("nums",nums)
    d=[0]*n
    d[0]=nums[0]
    for i in range(1,n):
        #d.append(nums[i]-nums[i-1])
        d[i]=nums[i]-nums[i-1]
    #print("差分",d)
    for i in range(m):
        cmd=list(map(int,input().split()))
        l=cmd[0]
        r=cmd[1]
        k=cmd[2]
        #print(nums)
        #print(l,r,k,d)
        d[l-1]+=k   # left 开始位置 加上k
        if r <n: # 避免右端点超出范围
            d[r]-=k  #  right+1 位置减去k
    #print(nums)
    # 还原数组
    res=[0]*n 
    res[0]=d[0]
    #print(res)
    for i in range(1,len(d)):
        res[i]=res[i-1]+d[i]
    # 拼接    
    #ret =str(res[0])
    #for i in range(1,len(res)):
    #    ret=ret+" "+str(res[i])
    ret=" ".join(map(str,res))
    print(ret)
func2()


"""


func1：直接遍历每个修改操作的区间，时间复杂度为 O (m*n)，当 n 和 m 达到 1e5 时会超时。

func2  :  使用差分数组 
原数组 ：a=[1,2,3]  k=4  执行操作输入 left=1, riht=2, k=4（即给区间 [0, 1] 的元素加 4）：
差分数组： diff=[1,1,1]

具体做法是：
假设坐标从0开始
差分数组修改：只需在差分数组的两个端点进行操作：
d[left] += k：表示从位置 l 开始的所有元素都增加 k。
d[right+1] -= k：表示从位置 r+1 开始的元素取消增加 k 的效果，从而将修改限制在区间 [left, right] 内。
还原原数组：修改完成后，通过前缀和运算即可得到修改后的原数组。


修改差分数组：
d[0] += 4 → d = [5, 1, 1]
d[2] -= 4 → d = [5, 1, -3]
还原原数组（前缀和）：
a[0] = d[0] = 5
a[1] = d[0] + d[0] = 5 + 1 = 6
a[2] = d[0] + d[1] + d[2] = 5 + 1 - 3 = 3

最终数组为 [5, 6, 3]，与直接遍历修改的结果一致，但操作复杂度从 O (n) 降为 O (1)
应用场景
差分数组适用于处理多次区间修改，单次查询最终结果的问题，例如：

频繁对数组区间进行增减操作。
游戏中的区域伤害计算。
航班座位预订统计等。
代码实现关键步骤
初始化差分数组：根据原数组计算相邻元素的差值。
处理区间修改：对差分数组的两个端点进行 O (1) 操作。
还原结果：通过前缀和运算将差分数组转换为最终数组。

这种方法特别适合处理大规模数据的区间修改问题，时间复杂度为 O (n + m)，其中 n 是数组长度，m 是操作次数。



测试用例  
3 2
1 2 3
1 2 4
3 3 -2  

其中 3 3 -2  测试 r =3  时候是边界 注意判断


"""