#if !__INCLUDE_LEVEL__
#include __FILE__

// using mint = modint;

void solve(){
  int n, m; cin >> n >> m;
  vector<pair<string, int>> sp(n); cin >> sp;
  sort(sp);
  int ans = 0;
  while(m--){
    string t; cin >> t;
    ans += lower_bound(sp, pair<string, int>{t, -inf})->second;
  }
  outln(ans);
}

/*

*/

signed main(){
  ios::sync_with_stdio(false); cin.tie(nullptr);
  out(fixed); out(setprecision(15));
  err(fixed); err(setprecision(15));

  int t = 1;
  // cin >> t;
  while(t--) solve();
}

#else // __INCLUDE_LEVEL
#if __has_include(<yoniha/all.h>)
#include <yoniha/all.h>
#else // no yoniha/all.h
#include <bits/stdc++.h>
using namespace std;

#if __has_include(<atcoder/all>)
#include <atcoder/all>
using namespace atcoder;
// ----------ACL用----------
// __has_include("atcoder/all")環境下に置く
// ----------入力----------
template <signed MOD>
istream& operator>>(istream& is, static_modint<MOD>& x) {
  signed w;
  is >> w;
  x = w;
  return is;
}
template <signed ID>
istream& operator>>(istream& is, dynamic_modint<ID>& x) {
  signed w;
  is >> w;
  x = w;
  return is;
}

// ----------出力----------
template <signed MOD>
ostream& operator<<(ostream& os, static_modint<MOD>& x) {
  return os << x.val();
}
template <signed ID>
ostream& operator<<(ostream& os, dynamic_modint<ID>& x) {
  return os << x.val();
}
// ----------ACL用ここまで----------
#endif // atdoder/all

// ----------bits/stdc++.h用----------
// yoniha/all.hがない環境下に置く
// ----------マクロ、便利関数----------
#define int long long
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define rrep(i, n) for(int i = (int)((n) - 1); i >= 0; i--)
template <typename T>
bool chmax(T& a, const T& b) {
  if(a < b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
bool chmin(T& a, const T& b) {
  if(a > b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T, class... Args>
void sort(vector<T>& a, Args&&... args) { sort(all(a), args...); }
template <typename T>
void reverse(vector<T>& a) { reverse(all(a)); }
template <typename T>
void unique_erase(vector<T>& a) { a.erase(unique(all(a)), a.end()); }
template <typename T>
auto min_element(vector<T>& a, auto&& comp = less()) { return min_element(all(a), comp); }
template <typename T>
auto max_element(vector<T>& a, auto&& comp = less()) { return max_element(all(a), comp); }
template <typename T, class... Args>
auto lower_bound(vector<T>& a, Args&&... args) { return lower_bound(all(a), args...); }
template <typename T, class... Args>
auto upper_bound(vector<T>& a, Args&&... args) { return upper_bound(all(a), args...); }
template <typename T, class... Args>
auto binary_search(vector<T>& a, Args&&... args) { return binary_search(all(a), args...); }
template <typename T>
auto next_permutation(vector<T>& a) { return next_permutation(all(a)); }
template <typename T, class... Args>
auto reduce(vector<T>& a, Args&&... args) { return reduce(all(a), args...); }

// ----------定数やusing----------
template <typename T>
using Dijk = priority_queue<T, vector<T>, greater<>>;
constexpr array<pair<int, int>, 4> dij{{{-1, 0}, {0, -1}, {1, 0}, {0, 1}}}; // 上から半時計周り
constexpr int inf = 1ll << 60;

// ----------ライブラリ----------


// ----------入力----------
istream& operator>>(istream& is, __int128_t& x) {
  int w;
  is >> w;
  assert(is);
  x = w;
  return is;
}
template <class T1, class T2>
istream& operator>>(istream& is, pair<T1, T2>& p) {
  auto&& [p1, p2] = p;
  is >> p1 >> p2;
  return is;
}
template <class... Ts>
istream& operator>>(istream& is, tuple<Ts...>& t) {
  apply([&](auto&... xs) { ((is >> xs), ...); }, t);
  return is;
}
template <class T>
istream& operator>>(istream& is, vector<T>& v) {
  for(auto&& x : v) is >> x;
  return is;
}
template <class... Args>
void in(Args&&... args) {
  ((cin >> args), ...);
}

// ----------出力----------
// ostream& operator<<(ostream& os, __int128_t& x) {
//   if(x == 0) return os << '0';
//   if(x < 0) os << '-';
//   string s;
//   __int128_t w = abs(x);
//   while(w > 0) {
//     s += char(w % 10 + '0');
//     w /= 10;
//   }
//   reverse(all(s));
//   return os << s;
// }
template <class T1, class T2>
ostream& operator<<(ostream& os, pair<T1, T2>& p) {
  auto&& [p1, p2] = p;
  return os << p1 << ' ' << p2;
}
template <class... Ts>
ostream& operator<<(ostream& os, tuple<Ts...>& t) {
  apply([&](auto&... xs) { ((os << xs), ...); }, t);
  return os;
}
template <class T>
ostream& operator<<(ostream& os, vector<T>& v) {
  for(size_t i = 0; i < v.size(); i++) os << v[i] << (i + 1 == v.size() ? "" : " ");
  return os;
}
void out() {} // 引数なしは何もしない(outln()がバグるのを防ぐ)
template <class T, class... Args>
void out(T&& first, Args&&... args) {
  cout << first;
  ((cout << ' ' << args), ...);
}
template <class... Args>
void outln(Args&&... args) {
  out(args...);
  cout << '\n';
}
void err() {} // 引数なしは何もしない(errln()がバグるのを防ぐ)
template <class T, class... Args>
void err(T&& first, Args&&... args) {
  cerr << first;
  ((cerr << ' ' << args), ...);
}
template <class... Args>
void errln(Args&&... args) {
  err(args...);
  cerr << '\n';
}

#endif // yoniha/all.h
#endif // __INCLUDE_LEVEL__