#include <bits/stdc++.h>
using namespace std;
const int INF = 999999999;
struct MinCostMaxFlow {
  int N;
  vector<vector<int> > cap, flow, cost;
  vector<int> found;
  vector<int> dist, pi, width;
  vector<pair<int, int> > dad;
  MinCostMaxFlow(int N)
      : N(N),
        cap(N, vector<int>(N)),
        flow(N, vector<int>(N)),
        cost(N, vector<int>(N)),
        found(N),
        dist(N),
        pi(N),
        width(N),
        dad(N) {}
  void AddEdge(int from, int to, int cap, int cost) {
    this->cap[from][to] = cap;
    this->cost[from][to] = cost;
  }
  void Relax(int s, int k, int cap, int cost, int dir) {
    int val = dist[s] + pi[s] - pi[k] + cost;
    if (cap && val < dist[k]) {
      dist[k] = val;
      dad[k] = make_pair(s, dir);
      width[k] = min(cap, width[s]);
    }
  }
  int Dijkstra(int s, int t) {
    fill(found.begin(), found.end(), false);
    fill(dist.begin(), dist.end(), INF);
    fill(width.begin(), width.end(), 0);
    dist[s] = 0;
    width[s] = INF;
    while (s != -1) {
      int best = -1;
      found[s] = true;
      for (int k = 0; k < N; k++) {
        if (found[k]) continue;
        Relax(s, k, cap[s][k] - flow[s][k], cost[s][k], 1);
        Relax(s, k, flow[k][s], -cost[k][s], -1);
        if (best == -1 || dist[k] < dist[best]) best = k;
      }
      s = best;
    }
    for (int k = 0; k < N; k++) pi[k] = min(pi[k] + dist[k], INF);
    return width[t];
  }
  pair<int, int> GetMaxFlow(int s, int t) {
    int totflow = 0, totcost = 0;
    while (int amt = Dijkstra(s, t)) {
      totflow += amt;
      for (int x = t; x != s; x = dad[x].first) {
        if (dad[x].second == 1) {
          flow[dad[x].first][x] += amt;
          totcost += amt * cost[dad[x].first][x];
        } else {
          flow[x][dad[x].first] -= amt;
          totcost -= amt * cost[x][dad[x].first];
        }
      }
    }
    return make_pair(totflow, totcost);
  }
};
const int M = 150;
MinCostMaxFlow m(M);
int so = M - 1;
int si = M - 2;
string s;
string w[109];
int nw[109][256], ns[256];
int a[109], n;
int main() {
  cin >> s;
  for (int i = 0; i < s.size(); i++) {
    ns[s[i]]++;
  }
  cin >> n;
  for (int i = 0; i < n; i++) {
    cin >> w[i] >> a[i];
  }
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < w[i].size(); j++) {
      nw[i][w[i][j]]++;
    }
  }
  for (int i = 0; i < n; i++) {
    m.AddEdge(so, i, a[i], 0);
    for (int j = 'a'; j <= 'z'; j++) {
      if (nw[i][j] <= 0) continue;
      m.AddEdge(i, n + (j - 'a'), nw[i][j], i + 1);
    }
  }
  for (int k = 'a'; k <= 'z'; k++) {
    if (ns[k] <= 0) continue;
    m.AddEdge((n) + (k - 'a'), si, ns[k], 0);
  }
  pair<int, int> res = m.GetMaxFlow(so, si);
  if (res.first == s.size()) {
    cout << res.second << endl;
  } else {
    cout << -1 << endl;
  }
  return 0;
}
