import scala.io.StdIn.{readInt, readLine};

object Main {
    def main(args: Array[String]): Unit = {
        val n = readInt;
        val preorder = readLine.split(" ").map(_.toInt);
        val inorder = readLine.split(" ").map(_.toInt);
        val (root, tree) = buildTree(n, preorder, inorder);
        println(postorder(root, tree).mkString(" "));
        
    }
    
    def buildTree(size: Int, preorder: Array[Int], inorder: Array[Int]): (Int, Array[Node]) = {
        val tree = new Array[Node](size + 1);
        def go(prePtr: Int, inFirst: Int, inLast: Int): (Int, Int) = {
            if (prePtr >= size) {
                (-1, prePtr);
            } else {
                val pivot = preorder(prePtr);
                val pivotIdx = inorder.indexOf(pivot);
                val (left, prePtr1) = if (inFirst == pivotIdx) (-1, prePtr) else go(prePtr + 1, inFirst, pivotIdx - 1);
                val (right, prePtr2) = if (inLast == pivotIdx) (-1, prePtr1) else go(prePtr1 + 1, pivotIdx + 1, inLast);
                tree(pivot) = Node(pivot, left, right);
                (pivot, prePtr2);
            }
        }
        go(0, 0, size - 1);
        (preorder(0), tree);
    }
    
    def postorder(root: Int, tree: Array[Node]): List[Int] = {
        def go(curr: Int, ret: List[Int]): List[Int] = {
            if (curr == -1) {
                ret;
            } else {
                val Node(id, left, right) = tree(curr);
                val ret1 = go(left, ret);
                val ret2 = go(right, ret1);
                val ret3 = id :: ret2;
                ret3;
            }
            
        }
        go(root, Nil).reverse;
    }
}
case class Node(id: Int, left: Int, right: Int);
