#include <iostream>
#include <vector>
#include <algorithm>

constexpr int nullNum = -1;

class Node{
public:
    Node() : 
    id( nullNum ), parent( nullptr ), left( nullptr ), right( nullptr ) {}

    void SetID( int id_ ){
        id = id_;
    }

    void SetParent( Node* prt ){
        parent = prt;
    }

    void SetLeft( Node* l ){
        left = l;
    }

    void SetRight( Node* r ){
        right = r;
    }

    int& ID(){
        return id;
    }

    // int Degree(){
    //     int deg = 0;
    //     deg += ( left )? 1 : 0;
    //     deg += ( right )? 1 : 0;
    //     return deg;
    // }

    // int Depth(){
    //     int depth = 0;
    //     Node* ptr = Parent();
    //     while( ptr ){
    //         ++depth;
    //         ptr = ptr->Parent();
    //     }
    //     return depth;
    // }

    // int Height( Node* const node ){
    //     if( !node || ( !node->Left() && !node->Right() ) ){
    //         return 0;
    //     }else{
    //         return 1 + std::max( Height( node->Left() ), Height( node->Right() ) );
    //     }
    // }

    Node* Parent(){
        return parent;
    }

    Node* Left(){
        return left;
    }

    Node* Right(){
        return right;
    }
    
    // Node* Sibling(){
    //     if( parent == nullptr ){
    //         return nullptr;
    //     }else if( this == parent->Left() ){
    //         return parent->Right();
    //     }else{
    //         return parent->Left();
    //     }
    // }

    // const char* CategoryName(){
    //     if( !parent ){
    //         return "root";
    //     }else if( !left && !right ){
    //         return "leaf";
    //     }
    //     return "internal node";
    //}

    void PreOrderTreeWalk( Node* node ){
        if( node ){
            std::cout << " " << node->ID();
            PreOrderTreeWalk( node->Left() );
            PreOrderTreeWalk( node->Right() );
        }
    }

    void InOrderTreeWalk( Node* node ){
        if( node ){
            InOrderTreeWalk( node->Left() );
            std::cout << " " << node->ID();
            InOrderTreeWalk( node->Right() );
        }
    }

    void PostOrderTreeWalk( Node* node ){
        if( node ){
            PostOrderTreeWalk( node->Left() );
            PostOrderTreeWalk( node->Right() );
            std::cout << " " << node->ID();
        }
    }
    
private:
    int id;
    Node* parent;
    Node* left;
    Node* right;
};

int main(){
    int n;
    std::cin.tie(0);
    std::cin >> n;

    std::vector<Node> tree(n);

    for( auto& elem : tree ){
        elem = Node();
    }
    
    int id;
    int lid;
    int rid; 
    for( int i = 0; i < n; ++i ){
        std::cin >> id >> lid >> rid;
        tree[id].SetID( id );
        if( lid != nullNum ){
            tree[id].SetLeft( &tree[lid] );
            tree[lid].SetParent( &tree[id] );
        }
        if( rid != nullNum ){
            tree[id].SetRight( &tree[rid] );
            tree[rid].SetParent( &tree[id] );
        }
    }

    Node* root = &tree[0];
    while( root->Parent() ){
        root = root->Parent();
    }

    // for( int i = 0; i < n; ++i ){
    //     std::cout << "node " << tree[i].ID();
    //     std::cout << ": parent = " << ( ( !tree[i].Parent() )? -1 : tree[i].Parent()->ID() );
    //     std::cout << ": left = " << ( ( !tree[i].Left() )? -1 : tree[i].Left()->ID() ) ;
    //     std::cout << ": right = " << ( ( !tree[i].Right() )? -1 : tree[i].Right()->ID() ) << "\n";
    // }

    //std::cout << root->ID();

    std::cout << "Preorder\n";
    root->PreOrderTreeWalk( root );

    std::cout << "\nInorder\n";
    root->InOrderTreeWalk( root );

    std::cout << "\nPostorder\n";
    root->PostOrderTreeWalk( root );
    std::cout << std::endl;

}


Measured memory_bytes: 3124