#include <bits/stdc++.h>

using namespace std;
#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,n,a) for (int i=n-1;i>=a;i--)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define srtv(x) sort(all(x))
#define len(a) a.size()
#define fi first
#define se second
#define lb lower_bound
#define ub upper_bound
typedef double db;
typedef long long int ll;
//#define int ll
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<vvvi> vvvvi;
typedef queue<int> qi;
typedef pair<int,int> pii;

ll q = 100000000000;

ll fast_power(ll a, ll k, ll &q)
{
    if(k==0)
        return 1;
    return (k%2==0) ? fast_power((a*a),k/2,q) : (a*fast_power((a*a),(k-1)/2,q));
}

int get_p(int n){
    for (int i = 2; i <=n; i++){
        if (n%i == 0)
            return i;
    }
    return 1;
}

// p^k = n
int get_k(int n, int p){
    int mpres = 1;
    for (int i = 1; ; i++){
        mpres*=p;
        if (mpres == n){
            return i;
        }
    }
}

int n, p, k;
int pizzo[1024];
string houses;
char best_cat;

char get_forcing_color(int start, int step){
    char fc = '?';
    bool flag = true;
      for (int i = start; i != start || flag; i = (i + step) % n){
        if (houses[i] != '?'){
            fc = houses[i]; break;
        }
        flag = false;
      }
      //cout<<"Forcing color "<<fc<<" for start "<<start<<" step "<<step<<endl;
      return fc;
}

// czy w ścieżce są dwa różne kolory?
bool is_selfcontradicting(int start, int step){
    vector<char> cats;
    bool flag = true;
    for (int i = start; i != start || flag; i = (i + step) % n){
        if (houses[i] != '?'){
            if (cats.size() > 0){
                if (cats[0] != houses[i]){
                    //cout<<"selfcontra for start "<<start<<" step "<<step<<endl;
                    return true;
                }
            }
            else {
                cats.pb(houses[i]);
            }
        }
        flag = false;
    }
    //cout<<"not selfcontra for start "<<start<<" step "<<step<<endl;
    return false;
}


void color_path(int start, int step, char col){
    bool flag = true;
    for (int i = start; i != start || flag; i = (i + step) % n){
        if (houses[i] == '?'){
            houses[i] = col;
        }
        flag = false;
    }
}

int calculate_profit(int start, int step, char cat){
    int profit;
    if (is_selfcontradicting(start, step)){
        profit =  0;
    }
    else if (get_forcing_color(start, step) != cat){
        profit = 0;
    }
    else if (step == 1){
        profit = n*pizzo[cat];
    }
    else profit = (n/step)*pizzo[cat]+ calculate_profit(start, step/p, cat);
    //cout<<"Profit "<<profit<<" for start "<< start<<" step "<<step<<" cat "<<cat<<endl;
    return profit;
}

char get_cat(int start, int step){
    // czy jesteśmy ścieżką o okresie 1? - ścieżka niższa nie istnieje, możemy wstawić dowolną kategorię
    // czy ścieżka niższa jest samosprzeczna?
    if (step == 1 || is_selfcontradicting(start, step/p)){
        color_path(start, step, best_cat);
        return best_cat;
    }
    // czy ścieżka niższa jest ścieżką pytajników?
    char fc = get_forcing_color(start, step/p) ;
    if (fc == '?'){
        char gc = get_cat(start, step/p);
        color_path(start, step, gc);
        return gc;
    } else {
        int k = get_k(n, step);
        int profit_fc = calculate_profit(start, step/p, fc) + pizzo[fc]*(fast_power(p, k+1, q) - 1)/(p-1);
        int profic_bc = pizzo[best_cat]*(fast_power(p, k+1, q) - 1)/(p-1);
        if (profit_fc > profic_bc){
            color_path(start, step, fc);
            return fc;
        }
        else{
            color_path(start, step, best_cat);
            return best_cat;
        }
    }
}




int main(){
    cin>>n;


    cin>>houses;

    int cat_cnt;
    cin>> cat_cnt;
    for (int i = 0; i < cat_cnt; i++){
        char cat; int cost;
        cin>>cat>>cost;
        pizzo[cat] = cost;
    }
    best_cat = 'A';
    for (char c = 'A'; c < 'A' + cat_cnt; c++){
        if (pizzo[c] > pizzo[best_cat]){
            best_cat = c;
        }
    }
int profit = 0;
    // TODO: corner case n = 1
    if (n!=1){
        p = get_p(n);
        k = get_k(n, p);
        
        rep(i,0,n){
            if (houses[i] == '?'){
                get_cat(i, n);
            }
        }
        // rep(i,0,n){
        //     cout<<houses[i];
        // }
        // cout<<endl;

        
        for (int step = 1; step <= n; step *= p){
            for (int i = 0; i < step; i++){
                if (!is_selfcontradicting(i, step)){
                    //cout<<"Adding profit start "<<i<<" step "<<step<<" val "<<pizzo[houses[i]]*(n/step)<<endl;
                    profit += pizzo[houses[i]]*(n/step);
                }
            }
        }
    }
    else{
        if (houses[0] == '?'){
            profit = pizzo[best_cat];
        }
        else profit = pizzo[houses[0]];
    }
    cout<<profit<<endl;
    return 0;
}