UVA

//本质是树的深度优先遍历

#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <cstring>
using namespace std;
const int INF = 1e9;

//因为各个结点的权值各不相同，且都是正数，直接用权值作为结点编号
const int maxv = 1e4 + 10;
int in_order[maxv], post_order[maxv], lch[maxv], rch[maxv];
//lch[root]的含义: 以root为根的树，其左子树的根，在后续遍历序列 post_order中的下标 
int n;

bool read_list(int *a)
{
	string line;
	if (!getline(cin, line)) return false;
	stringstream ss(line);
	n = 0; int x;
	while (ss >> x)
	a[n++] = x;
	return n > 0;
}

//按照中序遍历 in_order[L1...R1]和后序遍历 post_order[L2...R2]，建成一颗二叉树，返回树根
int build(int L1, int R1, int L2, int R2)
{
	if (L1 > R1) return 0; //空树
	int root = post_order[R2];
	int p = L1;
	while (in_order[p] != root) p++; //在中序遍历中找树根，以分离出树的左右子树
	int cnt = p - L1; //左子树的结点个数
	lch[root] = build(L1, p - 1, L2, L2 + cnt - 1); 
	rch[root] = build(p + 1, R1, L2 + cnt, R2 - 1); //这两条语句比较抽象，可以画图，好好理解下递归的关系，就会发现，其实也没有那么难理解  
	return root; 
} 

int best, best_sum; //目前为止的最优解和对应的权和

void dfs(int u, int sum)
{
	sum += u;
	if (!lch[u] && !rch[u]) //叶子
	{
		if (sum < best_sum || (sum == best_sum && u < best) )
		{
			best = u; best_sum = sum;
		}
	}
	if (lch[u]) dfs(lch[u], sum);
	if (rch[u]) dfs(rch[u], sum);
	//只要没有走到尽头(即叶子结点，即没有左子树和右子树的结点)，那么就得继续往下走，并累加权值sum；直到走到叶子结点 
	
} 

int main()
{
	while (read_list(in_order))
	{
		read_list(post_order);
		build(0, n - 1, 0, n - 1);
		best_sum = INF;
		dfs(post_order[n - 1], 0);
		cout << best << endl;
	}
	return 0;
}