using System;
using System.Collections.Generic;
using System.Linq;

namespace ALDS1_7C{
    public class Program{
        public static void Main(string[] args){
            var sr = new StreamReader();
            //---------------------------------
            var N = sr.Next<int>();
            var tree = new Tree(N);

            for(var i = 0; i < N; i++){
                var id = sr.Next<int>();
                var left = sr.Next<int>();
                var right = sr.Next<int>();
                tree.Add(id, left, right);
            }

            Console.WriteLine("Preorder");
            Console.WriteLine(" " + string.Join(" ", tree.PreOrder().Select(n => n.Id.ToString()).ToArray()));
            Console.WriteLine("Inorder");
            Console.WriteLine(" " + string.Join(" ", tree.InOrder().Select(n => n.Id.ToString()).ToArray()));
            Console.WriteLine("Postorder");
            Console.WriteLine(" " + string.Join(" ", tree.PostOrder().Select(n => n.Id.ToString()).ToArray()));
            //---------------------------------
        }
    }

    public class Tree{
        public readonly Node[] Nodes;

        public Tree(int cap){
            Nodes = new Node[cap];
            for(var i = 0; i < cap; i++){
                Nodes[i] = new Node(i);
            }
        }

        public void Add(int id, int left, int right){
            if(left != -1){
                Nodes[id].Left = Nodes[left];
                Nodes[left].Parent = Nodes[id];
            }
            if(right != -1){
                Nodes[id].Right = Nodes[right];
                Nodes[right].Parent = Nodes[id];
            }
        }

        public List<Node> PreOrder(){
            var res = new List<Node>();

            Action<Node> preParse = null;
            preParse = node =>{
                if(node == null) return;
                res.Add(node);
                preParse(node.Left);
                preParse(node.Right);
            };
            preParse(Nodes.First(n => n.Parent == null));

            return res;
        }

        public List<Node> InOrder(){
            var res = new List<Node>();

            Action<Node> inParse = null;
            inParse = node =>{
                if(node == null) return;
                inParse(node.Left);
                res.Add(node);
                inParse(node.Right);
            };
            inParse(Nodes.First(n => n.Parent == null));

            return res;
        }

        public List<Node> PostOrder(){
            var res = new List<Node>();

            Action<Node> postParse = null;
            postParse = node =>{
                if(node == null) return;
                postParse(node.Left);
                postParse(node.Right);
                res.Add(node);
            };
            postParse(Nodes.First(n => n.Parent == null));

            return res;
        }
    }

    public class Node{
        public int Id;
        public Node Parent;
        public Node Left;
        public Node Right;

        public Node(int id){
            Id = id;
        }
    }

    public class StreamReader{
        private readonly char[] _c = {' '};
        private int _index = -1;
        private string[] _input = new string[0];

        public T Next<T>(){
            if(_index == _input.Length - 1){
                _index = -1;
                while(true){
                    string rl = Console.ReadLine();
                    if(rl == null){
                        if(typeof(T).IsClass) return default(T);
                        return (T)typeof(T).GetField("MinValue").GetValue(null);
                    }
                    if(rl != ""){
                        _input = rl.Split(_c, StringSplitOptions.RemoveEmptyEntries);
                        break;
                    }
                }
            }
            return (T)Convert.ChangeType(_input[++_index], typeof(T), System.Globalization.CultureInfo.InvariantCulture);
        }

        public T[] Next<T>(int x){
            var ret = new T[x];
            for(var i = 0; i < x; ++i) ret[i] = Next<T>();
            return ret;
        }

        public T[][] Next<T>(int y, int x){
            var ret = new T[y][];
            for(var i = 0; i < y; ++i) ret[i] = Next<T>(x);
            return ret;
        }
    }
}

Measured memory_bytes: 10240