#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}



template<typename T>
struct PrimalDual{
  struct edge{
    Int to;
    T cap,cost;
    Int rev;
    edge(){}
    edge(Int to,T cap,T cost,Int rev):to(to),cap(cap),cost(cost),rev(rev){}
  };
  
  T INF;
  vector<vector<edge> > G;
  vector<T> h,dist;
  vector<Int> prevv,preve;

  PrimalDual(){}
  PrimalDual(Int n,T INF):INF(INF),G(n),h(n),dist(n),prevv(n),preve(n){}
  
  void add_edge(Int from,Int to,T cap,T cost){
    G[from].emplace_back(to,cap,cost,G[to].size());
    G[to].emplace_back(from,0,-cost,G[from].size()-1);
  }

  T flow(Int s,Int t,T f,Int &ok){    
    T res=0;
    fill(h.begin(),h.end(),0);
    while(f>0){
      using P = pair<T, Int>;
      priority_queue<P,vector<P>,greater<P> > que;
      fill(dist.begin(),dist.end(),INF);
      
      dist[s]=0;
      que.emplace(dist[s],s);
      while(!que.empty()){
        P p=que.top();que.pop();
        Int v=p.second;
        if(dist[v]<p.first) continue;
        for(Int i=0;i<(Int)G[v].size();i++){
          edge &e=G[v][i];
          if(e.cap==0) continue;
          if(dist[e.to]>dist[v]+e.cost+h[v]-h[e.to]){
            dist[e.to]=dist[v]+e.cost+h[v]-h[e.to];
            prevv[e.to]=v;
            preve[e.to]=i;
            que.emplace(dist[e.to],e.to);
          }
        }
      }
      if(dist[t]==INF) return ok=0;
      
      for(Int v=0;v<(Int)h.size();v++) h[v]+=dist[v];

      T d=f;
      for(Int v=t;v!=s;v=prevv[v])
        d=min(d,G[prevv[v]][preve[v]].cap);
      
      f-=d;
      res+=d*h[t];
      for(Int v=t;v!=s;v=prevv[v]){
        edge &e=G[prevv[v]][preve[v]];
        e.cap-=d;
        G[v][e.rev].cap+=d;
      }
    }
    ok=1;
    return res;
  }
};

//INSERT ABOVE HERE
signed main(){
  Int n;
  cin>>n;
  vector<Int> xs(n),ys(n),vs(n);
  for(Int i=0;i<n;i++) cin>>xs[i]>>ys[i]>>vs[i];

  Int m;
  cin>>m;
  vector<char> ts(m);
  vector<Int> as(m),bs(m);
  for(Int i=0;i<m;i++) cin>>ts[i]>>as[i]>>bs[i];

  const Int INF = 1e16;
  vector<Int> ls(n,-INF),rs(n,INF),ds(n,-INF),us(n,INF);
  for(Int i=0;i<m;i++){
    if(ts[i]=='L') chmax(ls[bs[i]],as[i]);
    if(ts[i]=='R') chmin(rs[bs[i]],as[i]);
    if(ts[i]=='D') chmax(ds[bs[i]],as[i]);
    if(ts[i]=='U') chmin(us[bs[i]],as[i]);
  }
  for(Int i=0;i+1<n;i++){
    chmax(ls[i+1],ls[i]);
    chmin(rs[i+1],rs[i]);
    chmax(ds[i+1],ds[i]);
    chmin(us[i+1],us[i]);
  }
  
  Int ans=0;
  for(Int k=1;k<=n;k++){
    PrimalDual<Int> G(k*2+n*2+2,INF);
    Int S=k*2+n*2,T=k*2+n*2+1;
    for(Int i=0;i<k;i++){
      G.add_edge(S,i,1,0);
      G.add_edge(k+i,T,1,0);
    }    
    
    for(Int p=0;p<n;p++){
      G.add_edge(k*2+p,k*2+n+p,1,INF-vs[p]);      
      for(Int i=0;i<k;i++){
        if(xs[p]<=ls[i]) continue;
        if(xs[p]>=rs[k-(i+1)]) continue;      
        G.add_edge(i,k*2+p,1,0);     
      }           
      for(Int j=0;j<k;j++){
        if(ys[p]<=ds[j]) continue;
        if(ys[p]>=us[k-(j+1)]) continue;    
        G.add_edge(k*2+n+p,k+j,1,0);
      }   
    }
    
    Int ok=1;
    Int res=G.flow(S,T,k,ok);    
    if(!ok) break;
    chmax(ans,INF*k-res);
  }
  cout<<ans<<endl;
  return 0;
}


Measured memory_bytes: 1228