#include <bits/stdc++.h>

const int MAXN = 150;

int ans = - INT_MAX, tmp = 0;

namespace Dinic {
	const int INF  = 1e3;
	
	struct Node {
		int to, nxt;
		int f;
	} E[MAXN << 6];
	
	int H[MAXN], tot = 1;
	
	inline void Add_Edge (const int u, const int v, const int f) {
		E[++ tot] = {v, H[u], f}, H[u] = tot;
		E[++ tot] = {u, H[v], 0}, H[v] = tot;
	}
	
	int S = 140, T = 145;
	int Cur[MAXN], Dep[MAXN];
	
	inline bool BFS () {
		std::fill (Dep, Dep + MAXN, -1);
		std::queue <int> q;
		q.push (S), Dep[S] = 0, Cur[S] = H[S];
		int u, v, f;
		while (!q.empty ()) {
			u = q.front (), q.pop ();
			for (int i = H[u]; i; i = E[i].nxt) {
				v = E[i].to, f = E[i].f;
				if (Dep[v] == -1 && f) {
					Dep[v] = Dep[u] + 1, Cur[v] = H[v], q.push (v);
					if (v == T) return 1;
				}
			}
		}
		return 0;
	}
	
	inline int DFS (const int x, const int MAXF) {
		if (x == T || MAXF == 0) return MAXF;
		int F = 0;
		for (int i = Cur[x]; i && F < MAXF; i = E[i].nxt) {
			Cur[x] = i;
			if (Dep[E[i].to] == Dep[x] + 1 && E[i].f) {
				int TmpF = DFS (E[i].to, std::min (MAXF - F, E[i].f));
				if (!TmpF) Dep[E[i].to] = -1;
				F += TmpF, E[i].f -= TmpF, E[i ^ 1].f += TmpF;
			}
		}
		return F;
	}
	
	inline int dinic () {
		int F = 0;
		while (BFS ()) F += DFS (S, INF);
		return F;
	}
}

struct nod {
	std::vector <int> k;
	int32_t w;
	
	inline bool operator < (const nod &a) const {
		return w < a.w;
	}
};

std::vector <int> v;
std::vector <nod> t;
int l[MAXN], r[MAXN], N;
int w[MAXN], stu[MAXN], tea[MAXN];

inline int Calc () {
	int ret = 0;
	for (auto i : v) ret += w[i];
	return ret;
}

inline void Add () {
	t.push_back ({v, Calc ()});
}

int n;
int c1, c2, c3, c4, c5;

inline int G (const int x, const int f = 0) {
	return x + f * 60;
}

inline void Solve () {
	if ((tmp = Calc ()) <= ans) return ++ c1, void ();
	for (auto i : v) if (stu[i] < i) return ++ c2, void ();
	for (int i = 1; i <= n; ++ i) tea[i] = 0;
	for (auto i : v) tea[i] = 1;
	for (int i = 1; i <= n; ++ i) tea[i] += tea[i - 1];
	for (int i = 1; i <= n; ++ i) 
		if (tea[r[i]] - tea[l[i] - 1] == 0)	
			return ++ c3, void ();
	
	memset (Dinic::H, 0, sizeof Dinic::H);
	Dinic::tot = 1;
	// memset (Dinic::H, 0, sizeof Dinic::H);
			
	for (int i = 1; i <= n; ++ i) Dinic::Add_Edge (Dinic::S, G (i, 0), 1);
	for (int i = 0; i < (int) v.size (); ++ i) Dinic::Add_Edge (G (i + 1, 1), Dinic::T, v[i]);
	for (int i = 1; i <= n; ++ i)
		for (int k = 0; k < (int) v.size (); ++ k)
			if (l[i] <= v[k] && v[k] <= r[i])
				Dinic::Add_Edge (G (i, 0), G (k + 1, 1), 1);
	
	int MaxF = Dinic::dinic ();
//	std::cerr << MaxF << ' ' << n << '\n';
	
	if (MaxF == n) ans = tmp, ++ c4;
	else ++ c5;
}

inline void dfs (const int n, const int lst = 1) {
	if (n == 0) return Add (), void ();
	for (int i = lst; i <= n; ++ i) v.push_back (i), dfs (n - i, i), v.pop_back ();
}

inline void solve () {
	
	std::sort (t.begin (), t.end ());
	
	for (int i = t.size () - 1; i >= 0; -- i) {
		v = t[i].k, Solve ();
		if (ans == t[i].w) return ;
	}
}

int main () {
	
	std::cin >> n;
	
	for (int i = 1; i <= n; ++ i) std::cin >> l[i] >> r[i], ++ stu[l[i]], -- stu[r[i] + 1];
	 
	for (int i = 1; i <= n; ++ i) std::cin >> w[i];
	
	for (int i = 1; i <= n; ++ i) stu[i] += stu[i - 1];
	
	dfs (n), solve ();
	
	std::cout << (ans == - INT_MAX ? "impossible" : std::to_string (ans)) << '\n';
	
	std::cerr << t.size () << ' ' << c1 << ' ' << c2 << ' ' << c3 << ' ' << c4 << ' ' << c5 << '\n';
	
	return 0;
}