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

namespace ALDS1_7_D
{
    class Program
    {
        static void Main(string[] args)
        {
            string line;

            //入力
            line = Console.ReadLine().Trim();
            var nodeCount = int.Parse(line);
            line = Console.ReadLine().Trim();
            var preorders = line.Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).Select(e => int.Parse(e)).ToArray();
            line = Console.ReadLine().Trim();
            var inorders = line.Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).Select(e => int.Parse(e)).ToArray();

            //再構成
            var nodes = new Nodes<int>();
            ReConstruct(nodes, preorders, inorders);
            Console.WriteLine(String.Join(" ", nodes.Postorder().Select(x => x.Value).ToArray()));
        }

        static void ReConstruct(Nodes<int> nodes, int[] preorders, int[] inorders)
        {
            var root = nodes.GetNode(preorders[0]);

            var inordersIdx = inorders.Select((val, idx) => new { val, idx }).Where(x => x.val == root.Value).Select(x => x.idx).First();

            var inorderLeft = inorders.Take(inordersIdx).ToArray();
            var inorderRight = inorders.Skip(inordersIdx + 1).ToArray();
            var preordersLeft = preorders.Skip(1).Take(inordersIdx).ToArray();
            var preordersRight = preorders.Skip(inordersIdx + 1).ToArray();

            if (preordersLeft.Length > 0)
            {
                nodes.SetLeft(root, preordersLeft[0]);
                ReConstruct(nodes, preordersLeft, inorderLeft);
            }
            if (inorderRight.Length > 0)
            {
                nodes.SetRight(root, preordersRight[0]);
                ReConstruct(nodes, preordersRight, inorderRight);
            }
        }
    }

    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: 20652