#include<queue>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int N = 100005, C = 10;

int n;

char s[N];

struct State;

const int INF = 1000000005;

State* top, *last[N];

struct State {
    int len, minPos;
    State *fa, *go[C];

    State(int len = 0) : len(len), fa(NULL) {
        memset(go, 0, sizeof(go));
        minPos = INF;
    }

    State* extend(State *start, int ch) {
        State *p = this;
        State *np = new(top++) State(len + 1);
        while (p && !p->go[ch]) {
            p->go[ch] = np;
            p = p->fa;
        }
        if (!p) {
            np->fa = start;
        } else {
            State *q = p->go[ch];
            if (p->len + 1 == q->len) {
                np->fa = q;
            } else {
                State *nq = new(top++) State(p->len + 1);
                memcpy(nq->go, q->go, sizeof(q->go));
                nq->fa = q->fa;
                np->fa = q->fa = nq;
                while (p && p->go[ch] == q) {
                    p->go[ch] = nq;
                    p = p->fa;
                }
            }
        }
        return np;
    }

};

State pool[N << 1];

int cost[C], a, b;

int nxt[N];

long long dp[N];

int main() { 
	scanf("%s", s);
	n = strlen(s);
	top = pool;
	State *root = new(top++) State(0);
	last[0] = root;
	for (int i = 0; i < n; ++i) {
		last[i + 1] = last[i]->extend(root, s[i] - '0');
	}
	for (int i = 0; i < n; ++i) {
		for (State *p = last[i + 1]; p && p->minPos == INF; p = p->fa) {
			p->minPos = i;
		}
	}
	State *u = root;
	int cur = 0, curLen = 0;
	for (int i = 0; i < n; ++i) {
		if (cur < i) {
			u = root;
			cur = i;
			curLen = 0;
		} else {
			if (u != root) {
				--curLen;
				if (curLen == u->fa->len) {
					u = u->fa;
				}
			}
		}
		while (cur + 1 < n && u->go[s[cur + 1] - '0']->minPos <= i) {
			u = u->go[s[++cur] - '0'];
			++curLen;
		}
		nxt[i] = cur;
	}
	for (int i = 0; i < 10; ++i) {
		scanf("%d", cost + i);
	}
	scanf("%d%d", &a, &b);
	dp[0] = cost[s[0] - '0'];
	deque<pair<long long, long long> > q;
	q.push_back(make_pair(nxt[0], dp[0] + b));
	for (int i = 1; i < n; ++i) {
		while (q.size() && q.front().first < i) {
			q.pop_front();
		}
		dp[i] = dp[i - 1] + cost[s[i] - '0'];
		if (q.size()) {
			dp[i] = min(dp[i], q.front().second + (long long)a * i);
		}
		long long cost = dp[i] - (long long)a * i + b;
		while (q.size() && q.back().second >= cost) {
			q.pop_back();
		}
		q.push_back(make_pair(nxt[i], cost));
	}
	cout << dp[n - 1] << endl;
    return 0;
}