#include <iostream>
#include <vector>
#include <algorithm> // min

using namespace std;

const int MAX_NODES = 10;

enum StateT {UNEXPLORED, OPEN, DONE};


struct NodeT{
    NodeT() {
       Reset();
    }

    void Reset() {
       number = -1;
       low = -1;
       color = UNEXPLORED;
       parent = -1;
    }

    vector<size_t> neighbors;
    StateT color;
    int number, low;
    size_t parent;
};

using namespace std;

void ReadGraph (vector<NodeT> & G)  {

    int start, end;

    cin >> start >> end;

    while (start != -1 and end!= -1) {
        G[start].neighbors.push_back(end);
        G[end].neighbors.push_back(start);
        cin >> start >> end;
    }
    return;
}

void DFSVisit(size_t node, vector<NodeT> & G, int & time) {
    G[node].color = OPEN;
    G[node].low = time;
    G[node].number = time++;
    for (auto i : G[node].neighbors) {
       if (G[i].color == UNEXPLORED) {
	   G[i].parent = node;
           DFSVisit(i, G, time);
	   G[node].low = min(G[node].low, G[i].low);
	   if (G[i].low >= G[node].number) {
	      cout << char('A' + node) << " is ap for " << char('A'+i) << endl;
	   }
       } else {
           if (G[node].parent != i) {
	       G[node].low = min(G[node].low, G[i].number);
	   }
       }
    }

    G[node].color = DONE;
    return;
}

void DFS(vector<NodeT> & G) {
   int time = 1;
   size_t node;
   for (node = 0; node < G.size(); node++) {
      if (G[node].color == UNEXPLORED) {
          DFSVisit(node, G, time);
      }
   }
   return;
}

void Print(vector<NodeT> & G) {
    cout << endl;
    for(size_t i = 0; i < G.size();i++) {
        cout << i <<   " " << G[i].number << " " << G[i].low << endl;
    }
    return;
}


int main() {

     int totalStations, targets;

     cin >> totalStations >> targets;
     while (totalStations > 0 and targets > 0) {
          vector<NodeT> G(totalStations);
          ReadGraph(G);
	  DFS(G);
	  Print(G);
	  cout << endl;
          cin >> totalStations >> targets;
     }
}