50 50
75 71 23 37 28 23 69 75 5 62 3 11 96 100 13 50 57 51 8 90 4 6 84 27 11 89 95 81 10 62 48 52 69 87 97 95 30 74 21 42 36 64 31 80 81 50 56 53 33 99
26 30 5 33 35 29 6 15 36 17 32 16 14 1 29 34 22 40 12 42 38 48 39 50 13 47 18 43 10 8 49 45 11 31 21 37 46 28 20 41 2 7 9 24 27 23 3 44 15 14
 10 10
61 59 97 16 2 94 57 48 91 93
2 8 6 5 3 1 3 4 9 10
 2 1
1 2
1
 3 3
10 20 30
1 2 3
 50 60
86 57 45 93 17 12 40 10 47 80 18 80 3 9 6 55 13 99 5 76 4 70 100 55 27 91 71 3 65 93 41 74 80 56 90 50 58 13 71 9 47 52 26 73 72 21 15 81 88 28
40 32 5 16 49 23 3 17 14 10 1 15 1 21 28 22 13 45 12 25 44 48 46 32 36 43 11 8 49 7 7 35 10 14 39 4 42 10 30 27 1 17 31 15 8 41 44 33 25 26 19 18 29 37 50 6 36 38 47 9
 2 7
20 30
1 1 1 2 2 2 2
 2 2
10 12
2 1
 5 1
16 87 36 16 81
3
 2 3
20 30
1 1 1
 2 10
39 26
1 1 2 2 2 2 2 2 1 2

63929
 2137
 0
 40
 62514
 20
 12
 0
 0
 104

#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(); }
