#include <stdlib.h>

template<class T> class List
{
	struct node {
		T data;
			node *next,*prev;
		} *f,*c;
public:
	int n,pos;
	List() {n=pos=0;}
	~List() {while(n) canc(); }
	T &cur() { return c->data; }
	T &operator[](int i) {go(i); return cur(); }
	T operator[](int i) const
	{
		 node *p=f;
		 while(i-->0) p=p->next;
		 return p->data;
	}
	void add(const T &t)
	{
		 c=f; pos=n;
		 ins(t);
	}
	void ins(const T &t)
	{
		node *w,*p;
		if(n)
		{
			w=c; p=c->prev;
			c=p->next=w->prev=new node;
			if(!pos) f=c;
		}
		else p=w=f=c=new node;
		c->prev=p;
		c->next=w;
		c->data=t;
		n++;
	}
	T canc()
	{
		node *w=c,*p=c->prev;
		T ret=c->data;
		c=p->next=w->next;
		c->prev=p;
		delete w;
		if(!pos) f=c;
		n--;
		return ret;
	}
	void next()
	{
		c=c->next;
		if(++pos==n) pos=0;
	}
	void prev()
	{
		c=c->prev;
		if(--pos<0) pos=n-1;
	}
	void go(int d) { skip(d-pos); }
	void skip(int d)
	{
		int dir=1;
		if(d<0) { d=-d; dir=0; }
		d%=n;
		if(d>n/2) {d=n-d; dir= !dir; }
		while(d--) dir?next():prev();
	}
	List &operator=(const List &a)
	{
		if(n) go(0); while(n) canc();
		for(int i=0;i<a.n;i++) add(a[i]);
		return *this;
	}
	List(const List &a)
	{
		n=pos=0;
		for(int i=0;i<a.n;i++) { add(a[i]);}
	}
};

struct none{} nul;
template<class T,class P, class A,int nmax> class Graph
{
public:
	struct arc
	{
		int node;
		A data;
		P peso;
	};
	struct node
	{
		T data;
		List<arc> in,out;
	} nodes[nmax];
	int n;
	
	Graph() {n=0;}
	void add_node(const T &t){ nodes[n++].data=t; }
	void add_arc_or(int s, int d, P p, A info)
	{
		 arc a; a.data=info; a.peso=p;
		 a.node=d; nodes[s].out.add(a);
		 a.node=s; nodes[d].in.add(a);
		}
	void add_arc_sym(int s,int d, P p, A i)
	{
		add_arc_or(s,d,p,i); if(s!=d) add_arc_or(d,s,p,i); }
	node &operator[](int i)
	{
		return nodes[i]; }
	List<int> shortest_path(int first, int last, P &p)
	{
		P pr[nmax];
		List<int> q,ret;
		int i,k,nod,bin[nmax],pred[nmax];
		for(i=0; i<n;i++) bin[i]=1;
		q.ins(first); pr[first]=0; bin[first]=0;
		while(q.n)
		{
			for(p=pr[q[i=0]];i<q.n;i++) if(pr[q[i]]<=p)
			p=pr[q[nod=i]];
			q.go(nod);
			if((nod=q.canc())==last)
			{
				while(ret.ins(nod),nod!=first) nod=pred[nod];
				if(nod==last) ret.ins(nod);
				return ret;
			}
			for(i=0;i<nodes[nod].out.n;i++)
			{
				arc a=nodes[nod].out[i]; k=a.node;
				if(pr[k]>p+a.peso || bin[k]) pr[k]=p+a.peso,
				pred[k]=nod;
				if(bin[k]) q.ins(k);
				bin[k]=0;
			}
		}
		p=-1; return ret;
	}
};

#include <stdio.h>
#include <string.h>

char nomi[100][25],s[25],c;
int addr[100],addgr[25],pr[100][1000],ttl[100][1000],totp[100];
int pid,t,i,j,k,ga,m,na,n,numg[25],gruppo[25][100],totgruppi;
int nn,nrouter,caso=0,numlinee,a,sorg,peso,h,totnodi;

FILE *fp=fopen("mbone.in","r");

int cercar() {
  int i;
  for(i=0;i<totnodi;i++)
    if (strcmp(s,nomi[i])==0) return i;
  return -1;  
}

int cercah(int h) {
  int i;
  for(i=0;i<totnodi;i++)
    if (addr[i]==h) return i;
  return -1;  
}

int cercag(int ga) {
  int i;
  for(i=0;i<totgruppi;i++)
    if (ga==addgr[i]) return i;
  return -1;  
}

void aggiungi(int ele, int ga) {
  int g;
  g=cercag(ga);
  gruppo[g][numg[g]]=cercah(ele);
  numg[g]++;
}

void togli(int ele, int ga) {
  int i,pos=-1;
  int g;
  g=cercag(ga);
  for(i=0;i<numg[g];i++)
    if (gruppo[g][i]==cercah(ele)) { pos=i; break; }
  for(i=pos;i<numg[g]-1;i++)
    gruppo[g][i]=gruppo[g][i+1];
  numg[g]--;    
}

void agggruppo(int ga) {
  int i,b=0;
  for(i=0;i<totgruppi;i++)
    if (ga==addgr[i]) b=1;
  if (b==0) {
    addgr[totgruppi]=ga;
    totgruppi++;
  }  
}

void inizia() {
  int i,j;
  for(i=0;i<25;i++) {
    numg[i]=0;
    addgr[i]=0;
    for(j=0;j<100;j++) gruppo[i][j]=0;
  }
  totgruppi=0;
  totnodi=0;
  for(i=0;i<100;i++) {
    strcpy(nomi[i],"");
    addr[i]=0;
    totp[i]=0;
    for(j=0;j<1000;j++) { pr[i][j]=0;ttl[i][j]=0; }
  }
}

void aggiungirouter() {
  strcpy(nomi[nn],s);
  addr[nn]=-1;
  nn++;
}

int main()
{
  fscanf(fp,"%d",&m);
  while (m!=0) {
    nn=0;
    Graph<none,int,none,200> g;
    inizia();
    printf("Network #%d\n",++caso);
    for(i=0;i<m;i++) {
      fscanf(fp,"%s %d",s,&numlinee);
      totnodi=nn;
      if (cercar()==-1) {
        g.add_node(nul);
        strcpy(nomi[nn],s);
        addr[nn]=-1;
        nrouter=nn;
        nn++;
      }
      else nrouter=cercar();  
      for(j=0;j<numlinee;j++) {
        fscanf(fp," %c %d",&c,&a);
        if (c=='H') {
          g.add_node(nul);
          strcpy(nomi[nn],"");
          addr[nn]=a;
          g.add_arc_sym(nrouter,nn,0,nul);
          nn++;
        }
        else {
          fscanf(fp,"%s",s);
          totnodi=nn;
          if (cercar()==-1) { 
            aggiungirouter();
            totnodi=nn;
          }  
          g.add_arc_or(nrouter,cercar(),a,nul);
       //printf("\n %d %d %d\n",nrouter,cercar(),a);
        } 
      }
    }
    totnodi=nn;
    // for(i=0;i<totnodi;i++) printf("%d %s %d\n",i,nomi[i],addr[i]);
    fscanf(fp,"%d",&na);
    for(i=0;i<na;i++) {
      fscanf(fp," %c %d %d",&c,&a,&ga);
      if (c=='J') {
        agggruppo(ga);
        aggiungi(a,ga); 
      }
      if (c=='L') togli(a,ga);
      if (c=='S') {
        fscanf(fp,"%d %d",&pid,&t);
        sorg=a;
        int gg=cercag(ga);
        for(j=0;j<numg[gg];j++) {
          int s2=gruppo[gg][j];
          g.shortest_path(cercah(sorg),s2,peso);
          //if (sorg==3768 && addr[s2]==51227) printf("\n %d %d \n",peso,t);
          if (peso<=t && peso!=-1) {
            pr[s2][totp[s2]]=pid;
            ttl[s2][totp[s2]]=t-peso;
            totp[s2]++;
          }
        }
      }
    }
    for(k=0;k<totnodi;k++) {
      if (totp[k]>0) {
        for(i=0;i<totp[k]-1;i++)
          for(j=i+1;j<totp[k];j++)
            if (pr[k][i]>pr[k][j]) {
              h=pr[k][i]; pr[k][i]=pr[k][j]; pr[k][j]=h;
              h=ttl[k][i]; ttl[k][i]=ttl[k][j]; ttl[k][j]=h; 
            }
      }
    }
    for(i=0;i<totnodi-1;i++)
      for(j=i+1;j<totnodi-1;j++)
        if (addr[i]>addr[j]) {
          h=addr[i]; addr[i]=addr[j]; addr[j]=h;
          h=totp[i]; totp[i]=totp[j]; totp[j]=h;
          for(k=0;k<1000;k++) {
            h=pr[i][k]; pr[i][k]=pr[j][k]; pr[j][k]=h;
            h=ttl[i][k]; ttl[i][k]=ttl[j][k]; ttl[j][k]=h;
          }
        }
    for(k=0;k<totnodi;k++)
      if(totp[k]>0)
        for(i=0;i<totp[k];i++)
          printf("%d %d %d\n",addr[k],pr[k][i],ttl[k][i]); 
    printf("\n");      
    fscanf(fp,"%d",&m);
  }	
  return 0;	
}