#include <bits/stdc++.h>
using namespace std;
const bool ready = []() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout << fixed << setprecision(12);
  return true;
}();
const double PI = acos(-1);
using ll = long long;
using pii = pair<ll, ll>;
using pdd = pair<double, double>;
using vd = vector<double>;
using vb = vector<bool>;
using vi = vector<ll>;
using vvi = vector<vi>;
using vs = vector<string>;
template <typename E>
class SegmentTree {
 private:
  vector<E> tree;
  E neutral;
  function<E(E, E)> cumul;
  ll treeDataOffset;
  const ll ROOT = 1;
  inline ll leftChild(const ll treeIdx) { return treeIdx * 2; }
  inline ll rightChild(const ll treeIdx) { return treeIdx * 2 + 1; }
  inline ll parent(const ll treeIdx) { return treeIdx / 2; }
  inline bool isOdd(const ll idx) { return (idx & 0x1); }

 public:
  template <typename Iterator>
  SegmentTree(Iterator beg, Iterator end, E pNeutral,
              function<E(E, E)> pCumul) {
    neutral = pNeutral;
    cumul = pCumul;
    treeDataOffset = (ll)distance(beg, end);
    tree = vector<E>(treeDataOffset * 2, pNeutral);
    ll i = treeDataOffset;
    for (auto it = beg; it != end; it++) tree[i++] = *it;
    for (ll j = treeDataOffset - 1; j >= 1; j--)
      tree[j] = cumul(tree[leftChild(j)], tree[rightChild(j)]);
  }
  void updateRange(ll pIdxL, ll pIdxR, function<E(E)> apply) {
    pIdxL += treeDataOffset;
    pIdxR += treeDataOffset;
    for (ll i = pIdxL; i < pIdxR; i++) tree[i] = apply(tree[i]);
    while (pIdxL != ROOT) {
      pIdxL = parent(pIdxL);
      pIdxR = max(pIdxL, parent(pIdxR - 1));
      for (ll i = pIdxL; i <= pIdxR; i++)
        tree[i] = cumul(tree[leftChild(i)], tree[rightChild(i)]);
    }
  }
  void updateApply(ll dataIdx, function<E(E)> apply) {
    updateSet(dataIdx, apply(get(dataIdx)));
  }
  void updateSet(ll dataIdx, E value) {
    ll treeIdx = treeDataOffset + dataIdx;
    tree[treeIdx] = value;
    while (treeIdx != ROOT) {
      treeIdx = parent(treeIdx);
      tree[treeIdx] =
          cumul(tree[leftChild(treeIdx)], tree[rightChild(treeIdx)]);
    }
  }
  E get(ll idx) { return tree[idx + treeDataOffset]; }
  E get(ll pIdxL, ll pIdxR) {
    ll idxL = pIdxL + treeDataOffset;
    ll idxR = pIdxR + treeDataOffset;
    E cum = neutral;
    while (idxL < idxR) {
      if (isOdd(idxL)) {
        cum = cumul(cum, tree[idxL]);
        idxL++;
      }
      if (isOdd(idxR)) {
        idxR--;
        cum = cumul(cum, tree[idxR]);
      }
      idxL = parent(idxL);
      idxR = parent(idxR);
    }
    return cum;
  }
};
void solve() {
  ll n;
  cin >> n;
  ;
  ll m;
  cin >> m;
  ;
  vi w(n);
  for (ll i = 0; i < ll(n); i++) {
    cin >> w[i];
  };
  vb vis(n);
  vi data(m);
  vi pos(n);
  vi r(m);
  for (ll i = 0; i < ll(m); i++) {
    cin >> r[i];
  };
  for (ll i = 0; i < m; i++) {
    cin >> r[i];
    r[i]--;
    if (!vis[r[i]]) {
      vis[r[i]] = true;
      data.push_back(w[r[i]]);
      pos[r[i]] = data.size() - 1;
    }
  }
  SegmentTree<ll> seg(data.begin(), data.end(), 0,
                      [](ll i1, ll i2) { return i1 + i2; });
  ll top = m - 1;
  ll ans = 0;
  for (ll i = 0; i < m; i++) {
    ans += seg.get(0, pos[r[i]]);
    seg.updateSet(top, w[r[i]]);
    seg.updateSet(pos[r[i]], 0);
    pos[r[i]] = top;
    top--;
  }
  cout << ans << endl;
}
signed main() { solve(); }
