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

namespace ALDS1_7_C
{
    class Program
    {
        static void Main(string[] args)
        {
            string line;
            int[] vals;

            //入力
            line = Console.ReadLine().Trim();
            var nodeCount = int.Parse(line);

            var nodes = new Nodes<int>();
            for (int i = 0; i < nodeCount; i++)
            {
                line = Console.ReadLine().Trim();
                vals = line.Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).Select(e => int.Parse(e)).ToArray();

                var node = nodes.GetNode(vals[0]);
                if (vals[1] != -1)
                {
                    nodes.SetLeft(node, vals[1]);
                }
                if (vals[2] != -1)
                {
                    nodes.SetRight(node, vals[2]);
                }
            }

            // 出力
            Console.WriteLine("Preorder");
            Console.WriteLine(" " + String.Join(" ", nodes.Preorder().Select(x => x.Value).ToArray()));
            Console.WriteLine("Inorder");
            Console.WriteLine(" " + String.Join(" ", nodes.Inorder().Select(x => x.Value).ToArray()));
            Console.WriteLine("Postorder");
            Console.WriteLine(" " + String.Join(" ", nodes.Postorder().Select(x => x.Value).ToArray()));

        }
    }

    public class Nodes<T>
    {
        private readonly Dictionary<T, Node> nodes = new Dictionary<T, Node>();

        public Node GetNode(T val)
        {
            Node node;
            if (!nodes.TryGetValue(val, out node))
            {
                node = new Node() { Value = val };
                nodes.Add(val, node);
            }
            return node;
        }

        public void SetLeft(Node node, T val)
        {
            var left = GetNode(val);
            left.Parent = node;
            node.Left = left;
        }

        public void SetRight(Node node, T val)
        {
            var right = GetNode(val);
            right.Parent = node;
            node.Right = right;
        }

        public Node GetRoot()
        {
            return nodes.Values.FirstOrDefault(x => x.Parent == null);
        }

        public IEnumerable<Node> Preorder(Node node = null)
        {
            if (node == null)
                node = GetRoot();

            yield return node;
            foreach (var child in node.Children())
            {
                foreach (var grandChild in Preorder(child))
                    yield return grandChild;
            }
        }

        public IEnumerable<Node> Inorder(Node node = null)
        {
            if (node == null)
                node = GetRoot();

            if (node.Left != null)
            {
                foreach (var grandChild in Inorder(node.Left))
                    yield return grandChild;
            }
            yield return node;
            if (node.Right != null)
            {
                foreach (var grandChild in Inorder(node.Right))
                    yield return grandChild;
            }
        }

        public IEnumerable<Node> Postorder(Node node = null)
        {
            if (node == null)
                node = GetRoot();

            foreach (var child in node.Children())
            {
                foreach (var grandChild in Postorder(child))
                    yield return grandChild;
            }
            yield return node;
        }

        public IEnumerable<Node> GetList()
        {
            return nodes.OrderBy(x => x.Key).Select(x => x.Value);
        }

        public class Node
        {
            public T Value { get; set; }
            public Node Parent { get; set; }
            public Node Left { get; set; }
            public Node Right { get; set; }

            public string NodeType
            {
                get
                {
                    if (Parent == null)
                    {
                        return "root";
                    }
                    if (Left != null || Right != null)
                    {
                        return "internal node";
                    }
                    return "leaf";
                }
            }

            public int GetDepth()
            {
               if (Parent == null)
                {
                    return 0;
                }
                return Parent.GetDepth() + 1;
            }

            public IEnumerable<Node> Children()
            {
                if (Left != null) yield return Left;
                if (Right != null) yield return Right;
            }

            public override string ToString()
            {
                return $"node {Value}: parent = {(Parent != null ? Parent.Value.ToString() : "-1")}, {NodeType}";
            }
        }
    }
}



Measured memory_bytes: 18456