Vasya has a string s of length n consisting only of digits 0 and 1. Also he has an array a of length n. 

Vasya performs the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue together the remaining parts (any of them can be empty). For example, if he erases substring 111 from string 111110 he will get the string 110. Vasya gets a_x points for erasing substring of length x.

Vasya wants to maximize his total points, so help him with this! 

Input

The first line contains one integer n (1 ≤ n ≤ 100) — the length of string s.

The second line contains string s, consisting only of digits 0 and 1.

The third line contains n integers a_1, a_2, ... a_n (1 ≤ a_i ≤ 10^9), where a_i is the number of points for erasing the substring of length i.

Output

Print one integer — the maximum total points Vasya can get.

Examples

Input


7
1101001
3 4 9 100 1 2 3


Output


109


Input


5
10101
3 10 15 15 15


Output


23

Note

In the first example the optimal sequence of erasings is: 1101001 → 111001 → 11101 → 1111 → ∅.

In the second example the optimal sequence of erasings is: 10101 → 1001 → 11 → ∅.
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.io.Closeable;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) throws Exception {
        Thread thread = new Thread(null, new TaskAdapter(), "", 1 << 27);
        thread.start();
        thread.join();
    }

    static class TaskAdapter implements Runnable {
        @Override
        public void run() {
            InputStream inputStream = System.in;
            OutputStream outputStream = System.out;
            FastInput in = new FastInput(inputStream);
            FastOutput out = new FastOutput(outputStream);
            EVasyaAndBinaryString solver = new EVasyaAndBinaryString();
            solver.solve(1, in, out);
            out.close();
        }
    }

    static class EVasyaAndBinaryString {
        long[][][][] dp;
        long[] profits;
        int[] flags;
        int n;
        long inf = (long) 1e18;
        PreSum ps;

        public void solve(int testNumber, FastInput in, FastOutput out) {
            n = in.readInt();
            flags = new int[n];
            for (int i = 0; i < n; i++) {
                flags[i] = in.readChar() - '0';
            }
            ps = new PreSum(flags);

            profits = new long[n + 1];
            for (int i = 1; i <= n; i++) {
                profits[i] = in.readInt();
            }

            dp = new long[2][n][n][n + 1];
            SequenceUtils.deepFill(dp, -1L);

            long ans = dp(0, 0, n - 1, 0);
            out.println(ans);
        }

        public long dp(int t, int l, int r, int remain) {
            if (l > r) {
                return remain == 0 ? 0 : -inf;
            }
            if (dp[t][l][r][remain] == -1) {
                dp[t][l][r][remain] = -inf;
                if (t == 1 && ps.intervalSum(l, r) < remain ||
                        t == 0 && (r - l + 1) - ps.intervalSum(l, r) < remain) {
                    return dp[t][l][r][remain];
                }

                for (int i = n; i > remain; i--) {
                    dp[t][l][r][remain] = Math.max(dp[t][l][r][remain],
                            dp(t, l, r, i) + profits[i - remain]);
                }
                if (remain == 0) {
                    for (int i = n; i > remain; i--) {
                        dp[t][l][r][remain] = Math.max(dp[t][l][r][remain],
                                dp(1 - t, l, r, i) + profits[i - remain]);
                    }
                    return dp[t][l][r][remain];
                }
                if (l == r) {
                    if (remain == 1) {
                        dp[t][l][r][remain] = t == flags[l] ?
                                0 : -inf;
                    } else if (remain > 1) {
                        dp[t][l][r][remain] = -inf;
                    }
                    return dp[t][l][r][remain];
                }
                for (int i = l; i <= r; i++) {
                    if (flags[i] != t) {
                        continue;
                    }
                    if (i < r) {
                        for (int k = 0; k <= remain; k++) {
                            dp[t][l][r][remain] = Math.max(dp[t][l][r][remain],
                                    dp(t, l, i, k) + dp(t, i + 1, r, remain - k));
                        }
                    } else {
                        for (int k = 0; k <= remain; k++) {
                            dp[t][l][r][remain] = Math.max(dp[t][l][r][remain],
                                    dp(t, l, i - 1, k) + dp(t, i, r, remain - k));
                        }
                    }
                }
            }

            return dp[t][l][r][remain];
        }

    }

    static class SequenceUtils {
        public static void deepFill(Object array, long val) {
            if (!array.getClass().isArray()) {
                throw new IllegalArgumentException();
            }
            if (array instanceof long[]) {
                long[] longArray = (long[]) array;
                Arrays.fill(longArray, val);
            } else {
                Object[] objArray = (Object[]) array;
                for (Object obj : objArray) {
                    deepFill(obj, val);
                }
            }
        }

    }

    static class PreSum {
        private long[] pre;

        public PreSum(long[] a) {
            int n = a.length;
            pre = new long[n];
            pre[0] = a[0];
            for (int i = 1; i < n; i++) {
                pre[i] = pre[i - 1] + a[i];
            }
        }

        public PreSum(int[] a) {
            int n = a.length;
            pre = new long[n];
            pre[0] = a[0];
            for (int i = 1; i < n; i++) {
                pre[i] = pre[i - 1] + a[i];
            }
        }

        public long intervalSum(int l, int r) {
            if (l > r) {
                return 0;
            }
            if (l == 0) {
                return pre[r];
            }
            return pre[r] - pre[l - 1];
        }

    }

    static class FastOutput implements AutoCloseable, Closeable {
        private StringBuilder cache = new StringBuilder(10 << 20);
        private final Writer os;

        public FastOutput(Writer os) {
            this.os = os;
        }

        public FastOutput(OutputStream os) {
            this(new OutputStreamWriter(os));
        }

        public FastOutput println(long c) {
            cache.append(c).append('\n');
            return this;
        }

        public FastOutput flush() {
            try {
                os.append(cache);
                os.flush();
                cache.setLength(0);
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
            return this;
        }

        public void close() {
            flush();
            try {
                os.close();
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }

        public String toString() {
            return cache.toString();
        }

    }

    static class FastInput {
        private final InputStream is;
        private byte[] buf = new byte[1 << 13];
        private int bufLen;
        private int bufOffset;
        private int next;

        public FastInput(InputStream is) {
            this.is = is;
        }

        private int read() {
            while (bufLen == bufOffset) {
                bufOffset = 0;
                try {
                    bufLen = is.read(buf);
                } catch (IOException e) {
                    bufLen = -1;
                }
                if (bufLen == -1) {
                    return -1;
                }
            }
            return buf[bufOffset++];
        }

        public void skipBlank() {
            while (next >= 0 && next <= 32) {
                next = read();
            }
        }

        public int readInt() {
            int sign = 1;

            skipBlank();
            if (next == '+' || next == '-') {
                sign = next == '+' ? 1 : -1;
                next = read();
            }

            int val = 0;
            if (sign == 1) {
                while (next >= '0' && next <= '9') {
                    val = val * 10 + next - '0';
                    next = read();
                }
            } else {
                while (next >= '0' && next <= '9') {
                    val = val * 10 - next + '0';
                    next = read();
                }
            }

            return val;
        }

        public char readChar() {
            skipBlank();
            char c = (char) next;
            next = read();
            return c;
        }

    }
}

