#include <bits/stdc++.h>
#define rep(i, s, n) for (int i = s; i < n; i++)
#define rp(i,n) for (int i=0;i<n;i++)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define all_acc(x) (x).begin(), (x).end(), 0LL
#define int long long
#define absSort(v) sort(a.begin(), a.end(), [](int i, int j) -> bool { return abs(i) < abs(j); });
using namespace std;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
using ll = long long;
double pi=3.14159265359;

void output_yoko(vector<int> s){
    int n = s.size();
    for (int i = 0; i < n; i++){
        //if (i != 0)
            cout << " ";
        cout << s[i];//<<endl;
    }
    cout << endl;
}

//出力形式を返す関数
string out(vector<int> v){
    string ans="[";
    for(int i=0;i<v.size();i++){
        if(i!=0) ans+=", ";
        ans+=to_string(v[i]);
    }
    ans+="]";
    return ans;
}

struct Node{
    //自分の親、左右の子、深さ、高さ、次数を保持
    int parent=-1,sibling=-1, left, right, depth=0 , height=0 ,degree;
    string status="internal node";
};

int n;
int NIL=-1;

void preorder(vector<Node> tree, int root, vector<int> &order){
    if(root!=-1){
        if(tree[root].status=="leaf") {
            order.push_back(root);
        }
        else{
            order.push_back(root);
            preorder(tree,tree[root].left,order);
            preorder(tree,tree[root].right,order);
        }    
        //if(order.size()==tree.size()) output_yoko(order);
        //cout<<order.size()<<endl;
    }
}

void inorder(vector<Node> tree,int root, vector<int> &order){
    if(root!=-1){
        if(tree[root].status=="leaf") {
            order.push_back(root);
        }
        else{
            inorder(tree,tree[root].left,order);
            order.push_back(root);
            inorder(tree,tree[root].right,order);
        }    
        //if(order.size()==tree.size()) output_yoko(order);
    }
}

void postorder(vector<Node> tree,int root, vector<int> &order){
    if(root!=-1){
        if(tree[root].status=="leaf") {
            order.push_back(root);
        }
        else{
            postorder(tree,tree[root].left,order);
            postorder(tree,tree[root].right,order);
            order.push_back(root);
        }    
        //if(order.size()==tree.size()) output_yoko(order);
    }
}

//深さを求める関数
void setDepthAll(vector<Node> &t,int parent){
    if(t[parent].parent==-1) t[parent].depth=0;
    
    if(t[parent].left!=-1) {
        t[t[parent].left].depth=t[parent].depth+1;
        setDepthAll(t,t[parent].left);
    }
    if(t[parent].right!=-1) {
        t[t[parent].right].depth=t[parent].depth+1;
        setDepthAll(t,t[parent].right);
    }
    
}

//高さを求める関数
void setHeightAll(vector<Node> &t,int parent){
    //葉の場合
    if(t[parent].left==-1 && t[parent].right==-1) {
        t[parent].height=0;
    }
    //それ以外の場合は、２つの子の高さの大きい方+1を選択する。
    else{
        //子のどちらかが存在しない場合を考える。
        if(t[parent].left==-1){
            setHeightAll(t,t[parent].right);
            t[parent].height=t[t[parent].right].height+1;
        }else if(t[parent].right==-1){
            setHeightAll(t,t[parent].left);
            t[parent].height=t[t[parent].left].height+1;
        }else{
            setHeightAll(t,t[parent].left);
            setHeightAll(t,t[parent].right);
            t[parent].height=max(t[t[parent].left].height,t[t[parent].right].height)+1;
        }
    }
}

//treeの情報を出力する関数。
void output_tree(vector<Node> t){
    int n=t.size();
    for(int i=0;i<n;i++){
        string ans="";
        ans+="node "+to_string(i)+": ";
        ans+="parent = "+to_string(t[i].parent)+", ";
        ans+="sibling = "+to_string(t[i].sibling)+", ";
        ans+="degree = "+to_string(t[i].degree)+", ";
        ans+="depth = "+to_string(t[i].depth)+", ";
        ans+="height = "+to_string(t[i].height)+", ";
        ans+=t[i].status;
        cout<<ans<<endl;
    }
}

signed main(){
    cin>>n;
    vector<Node> tree(n);

    for(int i=0;i<n;i++){
        int id,left,right; 
        cin>>id>>left>>right;

        //左右の子がない場合は葉です
        if(left==-1 && right==-1) {
            tree[id].status="leaf";
            tree[id].degree=0;
        }
        else if(left==-1 || right==-1) tree[id].degree=1;
        else tree[id].degree=2;
        
        //左右の子を保持する。
        tree[id].left=left;
        tree[id].right=right;

        //子に兄弟を知らせておく。
        if(right!=-1) tree[right].sibling=left;
        if(left!=-1) tree[left].sibling=right;

        //子の親を設定しておく。
        if(left!=-1) tree[left].parent=id;
        if(right!=-1) tree[right].parent=id;
    }

    int root_index=0;
    for(int i=0;i<n;i++){
        if(tree[i].parent==-1){
            root_index=i;
            tree[i].status="root";
            break;
        }
    }

    vector<int> order;
    cout<<"Preorder"<<endl;
    preorder(tree,root_index,order); output_yoko(order); order.clear();
    cout<<"Inorder"<<endl;
    inorder(tree,root_index,order); output_yoko(order); order.clear();
    cout<<"Postorder"<<endl;
    postorder(tree,root_index,order); output_yoko(order); order.clear();

    //setDepthAll(tree,root_index);

    //setHeightAll(tree,root_index);

    //output_tree(tree);
}


Measured memory_bytes: 3232