#include<map>
#include<sstream>
#include<cstdlib>
#include<vector>
#include<algorithm>
#include<iostream>
#include<cassert>
#define F first
#define S second
#define pb push_back
#define all(n) n.begin(),n.end()
using namespace std;
typedef pair<string,int> SI;
 
int oldest,youngest;
 
void split(vector<SI>& vec,string line)
{
  int space_cnt = 0;
  for(int i=0;line[i] == ' ';i++,space_cnt++){}
 
  vec.push_back(SI(line.substr(space_cnt,line.size()-space_cnt),space_cnt));
  oldest = min(oldest,space_cnt);
  youngest = max(youngest,space_cnt);
}
 
void ParseAndSolve(vector<SI>& vec,map<string,int>& index_tree,string line)
{
  vector<string> info;
  stringstream ss(line);
  string mid;
  vector<string> ope; 
  
 
  for(int i=0;i<ss.str().size();i++)
    {
      if((ss >> mid).fail())
    goto skip;
       
      ope.push_back(mid);
       
    }
 
 skip:
 
  info.push_back(ope[0]);
  for(int i=1;i<ope.size()-1;i++)
    {
      if(ope[i] == "child" || ope[i] == "parent" || ope[i] == "sibling" || ope[i] == "descendant" || ope[i] == "ancestor")
    {
      info.push_back(ope[i]);
      break;
    }
    }
  info.push_back(ope[ope.size()-1].substr(0,ope[ope.size()-1].size()));
 
 
  assert(info.size() == 3);
 
  string X,Y;
  X = info[0],Y = info[2];
 
  if(info[1][0] == 'c')
    {
      int Yindex = index_tree[Y];     
      int Xindex = index_tree[X];
 
      if(vec[Xindex].S <= vec[Yindex].S || Yindex+1 >= vec.size() || vec[Yindex+1].S != vec[Xindex].S)
    {
      cout << "False" << endl;
      return;
    }
 
    
      int parent_level = vec[Yindex].S;
 
      for(int i=Yindex+1;parent_level < vec[i].S && i < vec.size();i++)
    {
 
      if(vec[i].F == X)
        {
          cout << "True" << endl;
          return;
        }
    }
 
      cout << "False" << endl;
      return;
    }
  else if(info[1][0] == 'p')
    {
 
      int Xindex = index_tree[X];
      int Yindex = index_tree[Y];
 
      if(vec[Xindex].S >= vec[Yindex].S || Xindex+1 >= vec.size() || vec[Xindex+1].S != vec[Yindex].S )
    {
      cout << "False" << endl;
      return;
    }
 
 
      int parent_level = vec[Xindex].S;
 
      for(int i=Xindex+1;parent_level < vec[i].S && i < vec.size();i++ )
    {
      if(vec[i].F == Y)
        {
          cout << "True" << endl;
          return;
        }
    }
 
      cout << "False" << endl;
      return;
 
 
    }
  else if(info[1][0] == 's')
    {
      int Xindex = index_tree[X];
      int Yindex = index_tree[Y];
 
      if(vec[Xindex].S != vec[Yindex].S || min(Xindex,Yindex)+1 >= vec.size())
    {
      cout << "False" << endl;
      return;
    }
 
      int sibling_level = vec[Xindex].S;
 
      int Maxindex,Minindex;
      string Maxname,Minname;
 
      if(Xindex > Yindex)
    {
      Maxindex = Xindex,Minindex = Yindex;
      Maxname = X,Minname = Y;
    }
      else
    {
      Maxindex = Yindex,Minindex = Xindex;
      Maxname = Y,Minname = X;
    }
 
      for(int i=Minindex+1;i<vec.size() && sibling_level <= vec[i].S;i++)
    {
      if(Maxname == vec[i].F)
        {
          cout << "True" << endl;
          return;
        }
    }
      cout << "False" << endl;
      return;
 
    }
  else if(info[1][0] == 'd')
    {
      int Xindex = index_tree[X];
      int Yindex = index_tree[Y];
 
      if(Yindex+1 >= vec.size() || vec[Xindex].S <= vec[Yindex].S)
    {
      cout << "False" << endl;
      return;
    }
 
      for(int i=Yindex+1;i<vec.size() && vec[i].S > vec[Yindex].S;i++)
    {
      if(vec[i].F == vec[Xindex].F)
        {
          cout << "True" << endl;
          return;
        }
    }
 
      cout << "False" << endl;
      return;
    }
  else if(info[1][0] == 'a')
    {
      int Xindex = index_tree[X];
      int Yindex = index_tree[Y];
      if(Xindex+1 >= vec.size()  || vec[Xindex].S >= vec[Yindex].S)
    {
      cout << "False" << endl;
      return;
    }
 
      for(int i=Xindex+1;i < vec.size() && vec[i].S > vec[Xindex].S;i++)
    {
      if(vec[i].F == vec[Yindex].F)
        {
          cout << "True" << endl;
          return;
        }
    }
 
      cout << "False" << endl;
      return;
    }
  else
    assert(false);
   
 
}
 
int main()
{
  int n,m;
  while(true)
    {
      cin >> n >> m;
    
      if(!(n+m))
    break;
      oldest = (1<<28);
      youngest = -1;
      cin.ignore();
      string line;
      vector<SI> vec;
      for(int i=0;i<n;i++)
    {
      getline(cin,line);
     
      split(vec,line);
    }
 
      map<string,int> index_tree;
      for(int i=0;i<n;i++)
    index_tree[vec[i].F] = i;
 
      for(int i=0;i<m;i++)
    {
      getline(cin,line);
      
      ParseAndSolve(vec,index_tree,line.substr(0,line.size()-1));
      
    }
 
      cout << endl;
    }
  return 0;
}

Measured memory_bytes: 1360