#include <bits/stdc++.h>

const int MAXN = 155;

const int INF  = 1e4;

int ans = - INT_MAX, tmp = 0;

namespace MCMF {
	
	using namespace std;
	
    const int MAXN = 500;
	const int32_t INF = 10000; // Don't Be Too Large
	
	struct Edge {
		int u, v, nxt;
		int32_t f, w;
	} E[MAXN << 4];
	
	int H[MAXN], tot = 1;
	
	inline void Add_Edge (const int u, const int v, const int32_t f, const int32_t w) {
		E[++ tot] = {u, v, H[u], f, + w}, H[u] = tot;
		E[++ tot] = {v, u, H[v], 0, - w}, H[v] = tot;
	}
	
	int32_t Pre[MAXN];
	int fa[MAXN], fe[MAXN], Cir[MAXN], Tag[MAXN];
	int Now = 0, S = 145, T = 148;
	
	inline void Init_ZCT (const int x, const int e, int Nod = 1) {
		fe[x] = e, fa[x] = E[e].u, Tag[x] = Nod;
		for (int i = H[x]; i; i = E[i].nxt) 
			if (Tag[E[i].v] != Nod && E[i].f) Init_ZCT (E[i].v, i, Nod);
	}
	
	inline int32_t Sum (const int x) {
		if (Tag[x] == Now) return Pre[x];
		Tag[x] = Now, Pre[x] = Sum (fa[x]) + E[fe[x]].w;
		return Pre[x];
	}
	
	inline int32_t Push_Flow (const int x) {
		int rt = E[x].u, lca = E[x].v, Cnt = 0, Del = 0, P = 2;
		++ Now;
		while (rt) Tag[rt] = Now, rt = fa[rt];
		while (Tag[lca] != Now) Tag[lca] = Now, lca = fa[lca];
	
		int32_t F = E[x].f, Cost = 0;
		for (int u = E[x].u; u != lca; u = fa[u]) {
			Cir[++ Cnt] = fe[u];
			if (F > E[fe[u]].f) 
				F = E[fe[u]].f, Del = u, P = 0;
		}
	
		for (int u = E[x].v; u != lca; u = fa[u]) {
			Cir[++ Cnt] = fe[u] ^ 1;
			if (F > E[fe[u] ^ 1].f)
				F = E[fe[u] ^ 1].f, Del = u, P = 1;
		}
		Cir[++ Cnt] = x;
		
		for (int i = 1; i <= Cnt; ++ i) 
			Cost += F * E[Cir[i]].w, E[Cir[i]].f -= F, E[Cir[i] ^ 1].f += F;
		
		if (P == 2) return Cost;
		int u = E[x].u, v = E[x].v;
		if (P == 1) swap (u, v);
		int Lste = x ^ P, Lstu = v, Tmp;
		
		while (Lstu != Del) {
			Lste ^= 1, -- Tag[u];
			swap (fe[u], Lste);
			Tmp = fa[u], fa[u] = Lstu, Lstu = u, u = Tmp;
		}
		return Cost;
	}
	
	int32_t MinC = 0;
	
	inline int32_t Simplex () {
		Add_Edge (T, S, INF, - INF);
		Init_ZCT (T, 0, ++ Now);
		Tag[T] = ++ Now, fa[T] = 0;
		bool Run = 1;
		
		while (Run) {
			Run = 0;
			for (int i = 2; i <= tot; ++ i) 
				if (E[i].f && E[i].w + Sum (E[i].u) - Sum (E[i].v) < 0)
					MinC += Push_Flow (i), Run = 1;
		}
		
		MinC += E[tot].f * INF;
		return E[tot].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 (MCMF::H, 0, sizeof MCMF::H);
	memset (MCMF::Pre, 0, sizeof MCMF::Pre);
	MCMF::tot = 1;
	
//	Dinic::tot = 1;
	
	for (int i = 1; i <= n; ++ i) MCMF::Add_Edge (MCMF::S, G (i, 0), 1, 0);
	for (int i = 0; i < (int) v.size (); ++ i) MCMF::Add_Edge (G (i + 1, 1), MCMF::T, v[i], 0);
	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])
				MCMF::Add_Edge (G (i, 0), G (k + 1, 1), 1, 0);
	
	int MaxF = MCMF::Simplex ();
	
	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;
}