#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