#include <bits/stdc++.h>
const int INF = 1e9;

void Divide(int remain, int x, std::vector<int> &one_divide, 
std::vector<std::vector<int> > &all_divide, bool first = true) {
  assert(remain >= 0);
  if (remain == 0) {
    all_divide.emplace_back(one_divide);
    return;
  }
  for (int i = std::min(x, remain); i >= 1; --i) {
    one_divide.emplace_back(i);
    Divide(remain - i, i, one_divide, all_divide, false);
    one_divide.pop_back();
    if (first) break;
  }
}

void charming() {
  int n; std::cin >> n;

  std::vector<std::pair<int, int> > stu(n);
  for (int i = 0, l, r; i < n; ++i) {
    std::cin >> l >> r;
    stu[i] = std::make_pair(l, r);
  }
//  sort(stu.begin(), stu.end(), [&](std::pair<int, int> &x,
//	std::pair<int, int> &y) {
//		if (x.second != y.second) return x.second < y.second;
//		else return x.first < y.first;
//	});
	sort(stu.begin(), stu.end());

  std::vector<int> w(n + 1);
  for (int i = 1; i <= n; ++i) std::cin >> w[i];

  std::vector<std::vector<int> > divide;
  for (int i = 1; i <= n; ++i) {
    std::vector<int> vec;
    Divide(n, i, vec, divide);
  }

  int ans = -INF;
	std::vector<int> vis(n + 1);
	
  std::function<int(std::vector<int> &)> Solve 
  = [&](std::vector<int> &team) {
    int nans = 0;
    for (int x : team) nans += w[x];
    if (nans < ans) return -INF;
//		else {
//			std::vector<int> pre(n + 1);
//			for (int i = 1; i <= n; ++i) pre[i] = vis[i] + pre[i - 1];
//			for (auto [l, r] : stu) if (pre[r] - pre[l - 1] <= 0) return false;
//		}
//
//		int p = 0;
//		while (p < n) {
//			for (int x : team) {
//				while (p < n && stu[p].second < x) ++p;
//				if (p >= n) break
//				int r = x;
//				while (r) {
//					if (p >= n) return false;	
//				}
//			}
//		}

//		reverse(team.begin(), team.end());
//		int cnt = team.size();
//		std::vector<int> pre(cnt + 1);
//		for (int i = 1; i <= cnt; ++i) {
//			pre[i] = pre[i - 1] + team[i - 1];
//		}
//		
//		std::vector<std::pair<int, int> > interval;
//		for (int i = 0, l = 0, r = 0; i < n; ++i) {
//			while (l <= cnt && team[l + 1] < stu[i].first) ++l;
//			if (l > cnt) return -INF;
//			
//			while (r + 1 <= cnt && team[r + 1] <= stu[i].second) ++r;
//			interval.emplace_back(std::make_pair(pre[l - 1] + 1, pre[r]));
//		}
//		
//		for (int i = 1; i <= n; ++i) {
//			if (interval[i - 1].second > i) return -INF;
//		}

		reverse(team.begin(), team.end());
		for (int i = 0, p = 0, c = 0; i < n; ++i) {
			if (stu[i].first > team[p] || stu[i].second < team[p]) return -INF;
			++c;
			if (c >= team[p]) ++p, c = 0;
		}
		return nans;
  };

  
  for (auto vec : divide) ans = std::max(ans, Solve(vec));

  if (ans <= -INF) std::cout << "impossible\n";
  else std::cout << ans << '\n';
}

signed main() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(NULL);
  std::cout.tie(NULL);
  charming();
  return 0;
}