{$A+,B-,D+,E-,F-,G+,I+,L+,N+,O-,P-,Q-,R-,S-,T-,V+,X+,Y+}
{$M 65520,0,655360}
{by Behdad Esfahbod}
{Relations}
program
  Relations;

type
  DataType = Integer;

type
  PRangeNode = ^ RangeNode;
  RangeNode = record
    Data: DataType;
    Next: PRangeNode;
  end;

  PDomainNode = ^ DomainNode;
  DomainNode = record
    List: PRangeNode;
    Data: DataType;
    Next: PDomainNode;
  end;

const
  RelationsNumber = 1000;

var
  Rel: array[1 .. RelationsNumber] of PDomainNode;

procedure Create (I: Integer);
begin
  New(Rel[I]);
  Rel[I] := nil;
end;

procedure CreateDomainNode (V: Datatype; var U: PDomainNode);
begin
  New(U);
  U^.Data := V;
  U^.List := nil;
  U^.Next := nil;
end;

procedure CreateRangeNode (V: Datatype; var U: PRangeNode);
begin
  New(U);
  U^.Data := V;
  U^.Next := nil;
end;

procedure FindCreateDomainNode (R: Integer; V: DataType; var U: PDomainNode);
var
  F: PDomainNode;
begin
  if (Rel[R] = nil) or (Rel[R]^.Data > V)  then
  begin
    CreateDomainNode(V, U);
    U^.Next := Rel[R];
    Rel[R] := U;
  end
  else
  begin
    U := Rel[R];
    while (U^.Next <> nil) and (U^.Data < V) do
      U := U^.Next;
    if U^.Data <> V then
    begin
      CreateDomainNode(V, F);
      F^.Next := U^.Next;
      U^.Next := F;
      U := F;
    end;
  end;
end;

procedure FindDomainNode (R: Integer; V: DataType; var U: PDomainNode);
var
  F: PDomainNode;
begin
  if (Rel[R] = nil) or (Rel[R]^.Data > V)  then
    U := nil
  else
  begin
    U := Rel[R];
    while (U^.Next <> nil) and (U^.Data < V) do
      U := U^.Next;
    if U^.Data <> V then
      U := nil;
  end;
end;

procedure FindCreateRangeNode(V: PDomainNode; Va: DataType; var U: PRangeNode);
var
  F: PRangeNode;
begin
  if (V^.List = nil) or (V^.List^.Data > Va) then
  begin
    CreateRangeNode(Va, U);
    U^.Next := V^.List;
    V^.List := U;
  end
  else
  begin
    U := V^.List;
    while (U^.Next <> nil) and (U^.Data < Va) do
      U := U^.Next;
    if U^.Data <> Va then
    begin
      CreateRangeNode(Va, F);
      F^.Next := U^.Next;
      U^.Next := F;
      U := F;
    end;
  end;
end;

procedure FindRangeNode (V: PDomainNode; Va: Datatype; var U, U2: PRangeNode);
var
  F: PRangeNode;
begin
  if (V^.List = nil) or (V^.List^.Data > Va) then
    U := nil
  else
  begin
    U := V^.List;
    while (U <> nil) and (U^.Data < Va) do
    begin
      U2 := U;
      U := U^.next;
    end;
    if U^.Data <> Va then
      U := nil;
  end;
end;

procedure Insert (R: Integer; V, U: DataType);
var
  I, J: Integer;
  X: PDomainNode;
  Y: PRangeNode;
begin
  FindCreateDomainNode(R, V, X);
  FindCreateRangeNode(X, U, Y);
end;

procedure Lookup(R: Integer; V, U: DataType);
var
  X: PDomainNode;
  Y, Y2: PRangeNode;
begin
  FindDomainNode(R, V, X);
  if X = nil then  WriteLn(False)
  else  begin
    FindRangeNode(X, U, Y, Y2);
    if Y = nil then
      WriteLn(False)
    else
      WriteLn(true);
  end;
end;

procedure Print (R: Integer; V: DataType);
var
  X: PDomainNode;
  Y: PRangeNode;
  Fl: Boolean;
begin
  Fl := False;
  X := Rel[R];
  while (X <> nil) and (X^.Data < V) do
    X := X^.Next;
  if (X <> nil) and (X^.Data = V) then
  begin
    Y := X^.List;
    while Y <> nil do  begin
      if Fl then
        Write(', ');
      Fl := true;
      Write(Y^.Data);
      Y := Y^.Next;
    end;
  end;
  Writeln;
end;

procedure Union (R1, R2: Integer);
var
  X: PDomainNode;
  Y: PRangeNode;
begin
  X := Rel[R2];
  while (X <> nil) do begin
    Y := X^.List;
    while Y <> nil do  begin
      Insert(R1, X^.Data, Y^.Data);
      Y := Y^.Next;
    end;
    X := X^.Next;
  end;
end;

procedure Delete (R: Integer; V, U: DataType);
var
  X: PDomainNode;
  Y, Y2: PRangeNode;
begin
  FindDomainNode(R, V, X);
  if X <> nil then
  begin
    FindRangeNode(X, U, Y, Y2);
    if Y <> nil then
      if X^.List^.Data = U then
        X^.List := X^.List^.Next
      else
        Y2^.Next := Y^.Next;
  end;
end;

procedure KeyboardInput;
var
  C: Char;
  I, J, K, L: Integer;
begin
  while not Eof(Input) do
  begin
    Read(C);
    case UpCase(C) of
      'C': begin
        ReadLn(I);
        Create(I);
      end;
      'I': begin
        ReadLn(I, J, K);
        Insert(K, I, J);
      end;
      'P': begin
        ReadLn(I, J);
        Print(J, I);
      end;
      'U': begin
        ReadLn(I, J);
        Union(I, J);
      end;
      'L': begin
        ReadLn(I, J, k);
        LookUp(K, I, J);
      end;
      'D': begin
        Readln(I, J, K);
        Delete(K, I, J);
      end;
    end;
  end;
end;

procedure FileInput;
begin
  FillChar(Rel, SizeOf(Rel), 0);
  Assign(Input, 'input.txt');
  Reset(Input);
  Assign(Output, 'output.txt');
  Rewrite(Output);
  KeyboardInput;
  Close(Input);
  Close(Output);
end;

begin
  Writeln(0);
  Readln;
  KeyboardInput;
  FileInput;
end.