{.checks:off.}
import sequtils,strutils,algorithm,future
type DualSegTree[T]=object
  n:int
  data:seq[T]
  unit:T
  f:(T,T)->T
proc initDualSegTree[T](n:int,unit:T,f:(T,T)->T):DualSegTree[T]=
  result.n=n
  result.data=newSeq[T] n*2
  result.data.fill unit
  result.unit=unit
  result.f=f
proc propagate[T](self:var DualSegTree[T],i:int)=
  var
    j=i
    c=0
  while j>0:
    j=j div 2
    c+=1
  for j in countdown(c-1,1):
    let k=i shr j
    if k>=self.n:
      break
    self.data[k*2]=self.f(self.data[k*2],self.data[k])
    self.data[k*2+1]=self.f(self.data[k*2+1],self.data[k])
    self.data[k]=self.unit
proc update[T](self:var DualSegTree[T],left,right:int,x:T)=
  var
    l=left+self.n
    r=right+self.n
  self.propagate l
  self.propagate r
  while l<r:
    if(l and 1)==1:
      self.data[l]=self.f(self.data[l],x)
      l+=1
    if(r and 1)==1:
      r-=1
      self.data[r]=self.f(self.data[r],x)
    l=l div 2
    r=r div 2
proc query[T](self:var DualSegTree[T],i:int):T=
  var j=i+self.n
  self.propagate(j)
  return self.data[j]
var n,q:int
(n,q)=stdin.readLine.split.map parseInt
var
  a=stdin.readLine.split.map parseInt
  b=newSeq[int] n
  c=initDualSegTree(n,0,(a,b)=>a+b)
for _ in 1..q:
  let
    t=stdin.readLine.split
    x=parseInt(t[1])-1
    y=parseInt t[2]
  case t[0]
  of "A":
    b[x]+=a[x]*c.query x
    c.update(x,x+1,-c.query x)
    a[x]+=y
  of "B":
    c.update(x,y,1)
for x,y in a:
  b[x]+=y*c.query x
echo b.mapIt($it).join" "