// Główna idea:
// 1. Traktujemy rozwinięte t jako wykres balansu prefiksowego P(x).
// 2. Dla ustalonego progu T patrzymy na wszystkie pozycje, gdzie P(x) >= T.
// 3. DP po segmentach s aktualizuje zbiór osiągalnych pozycji w t.
// 4. Na końcu liczymy te końce, które mają dokładnie oczekiwany balans.

#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

typedef long long ll;
typedef pair<ll, ll> interval;

struct segment
{
    int dir;
    ll cnt;
};

// słowo t
int t_segments_count;
vector<segment> t_segments;
vector<ll> t_segment_pos;
vector<ll> t_segment_balance;
ll t_length;
ll t_min_balance;
ll t_max_balance;

// s
int s_segments_count;
vector<segment> s_segments;
vector<ll> s_boundary_balance;
ll s_length;
ll s_total_balance;

// wczytaywanie RLE
void read_word(vector<segment>& segments)
{
    int blocks;
    char first_char;
    cin >> blocks >> first_char;

    segments.resize(blocks);
    for (int i = 0; i < blocks; i++)
    {
        ll length;
        cin >> length;

        bool same_as_first = (i % 2 == 0);
        if (same_as_first)
            segments[i].dir = (first_char == '(' ? 1 : -1);
        else
            segments[i].dir = (first_char == '(' ? -1 : 1);

        segments[i].cnt = length;
    }
}

void init_t_data()
{
    t_segments_count = (int)t_segments.size();
    t_segment_pos.resize(t_segments_count + 1);
    t_segment_balance.resize(t_segments_count + 1);

    t_segment_pos[0] = 0;
    t_segment_balance[0] = 0;

    for (int i = 0; i < t_segments_count; i++)
    {
        t_segment_pos[i + 1] = t_segment_pos[i] + t_segments[i].cnt;
        t_segment_balance[i + 1] = t_segment_balance[i] + (ll)t_segments[i].dir * t_segments[i].cnt;
    }

    t_length = t_segment_pos[t_segments_count];
    t_min_balance = *min_element(t_segment_balance.begin(), t_segment_balance.end());
    t_max_balance = *max_element(t_segment_balance.begin(), t_segment_balance.end());
}



void init_s_data()
{
    s_segments_count = (int)s_segments.size();
    s_boundary_balance.resize(s_segments_count + 1);
// oznacza zmianę balansu po przejściu przez pierwsze i segmentów
    s_boundary_balance[0] = 0;
    s_length = 0;

    for (int i = 0; i < s_segments_count; i++)
    {
        s_length += s_segments[i].cnt;
        s_boundary_balance[i + 1] = s_boundary_balance[i] + (ll)s_segments[i].dir * s_segments[i].cnt;
    }

    s_total_balance = s_boundary_balance[s_segments_count];
}

// indeks segmentu t, który zawiera pozycję pos w t
int find_t_segment(ll pos)
{
    int left = 0;
    int right = t_segments_count - 1;

    while (left < right)
    {
        int mid = (left + right + 1) / 2;
        if (t_segment_pos[mid] <= pos)
            left = mid;
        else
            right = mid - 1;
    }

    return left;
}

// P(pos) = balans prefiksowy słowa t w punkcie pos
ll prefix_balance_at(ll pos)
{
    if (pos <= 0)
        return 0;

    if (pos >= t_length)
        return t_segment_balance[t_segments_count];

    int segment_id = find_t_segment(pos);
    return t_segment_balance[segment_id] + (ll)t_segments[segment_id].dir * (pos - t_segment_pos[segment_id]);
}

bool get_mask_interval(int segment_id, ll threshold, ll& left_end, ll& right_end)
{
    ll segment_balance = t_segment_balance[segment_id];
    ll segment_start = t_segment_pos[segment_id];
    ll segment_finish = t_segment_pos[segment_id + 1];
    ll segment_length = t_segments[segment_id].cnt;

    if (t_segments[segment_id].dir == 1)
    {
        //  '(' balans rośnie, więc dopuszczalny fragment zaczyna się 1 gdzie dobijemy do threshold
        left_end = segment_start + max(0LL, threshold - segment_balance);
        right_end = segment_finish;
        if (left_end > segment_finish)
            return false;
    }
    else
    {
        left_end = segment_start;
        right_end = segment_start + min(segment_length, segment_balance - threshold);
        if (right_end < segment_start)
            return false;
    }

    return left_end <= right_end;
}


// reach oznacza aktualny zbiór osiągalnych przedziałów w t
// - > punktów z P(x) >= th i robimy flood fill
vector<interval> batch_step(const vector<interval>& reach, ll threshold)
{
    if (reach.empty())
        return {};

    if (threshold > t_max_balance)
        return {};

    if (threshold <= t_min_balance)
        return {{reach[0].first, t_length}};

    vector<interval> next_reach;
    int reach_id = 0;
    bool active_component = false;
    ll component_left = 0;
    ll component_right = 0;

    for (int segment_id = 0; segment_id < t_segments_count; segment_id++)
    {
        ll mask_left;
        ll mask_right;
        if (!get_mask_interval(segment_id, threshold, mask_left, mask_right))
        {
            if (active_component)
            {
                next_reach.push_back({component_left, component_right});
                active_component = false;
            }
            continue;
        }

        if (active_component)
        {
            component_right = mask_right;
        }
        else
        {
            while (reach_id < (int)reach.size() && reach[reach_id].second < mask_left)
                reach_id++;

            if (reach_id < (int)reach.size())
            {
                ll seed_left = max(reach[reach_id].first, mask_left);
                ll seed_right = min(reach[reach_id].second, mask_right);

                if (seed_left <= seed_right)
                {
                    component_left = seed_left;
                    component_right = mask_right;
                    active_component = true;
                }
            }
        }

        if (!(segment_id + 1 < t_segments_count && t_segment_balance[segment_id + 1] >= threshold))
        {
            if (active_component)
            {
                next_reach.push_back({component_left, component_right});
                active_component = false;
            }
        }
    }

    if (active_component)
        next_reach.push_back({component_left, component_right});

    return next_reach;
}

//  pełne DP dla jednego startu w t
// #1 pozycje o balansie >= P(start),
// przesuwać próg zgodnie z kolejnymi granicami w s
vector<interval> evaluate_reach(ll start_pos)
{
    ll start_balance = prefix_balance_at(start_pos);

    vector<interval> reach = batch_step({{start_pos, start_pos}}, start_balance);
    if (reach.empty())
        return {};

    for (int i = 0; i < s_segments_count; i++)    {
        ll exit_threshold = start_balance - s_boundary_balance[i + 1];
        reach = batch_step(reach, exit_threshold);

        if (reach.empty())
            return {};
    }

    return reach;
}

// dla danego segmentu i szukanego balansu target_balance -> wykres P(x) osiąga tę wartość.
// max 1
ll find_end_position_in_segment(int segment_id, ll target_balance)
{
    ll segment_balance = t_segment_balance[segment_id];
    ll segment_start = t_segment_pos[segment_id];
    ll segment_length = t_segments[segment_id].cnt;
    ll offset;

    if (t_segments[segment_id].dir == 1)
        offset = target_balance - segment_balance;
    else
        offset = segment_balance - target_balance;

    if (offset < 0 || offset > segment_length)
        return -1;

    if (offset == segment_length && segment_id < t_segments_count - 1)
        return -1;

    return segment_start + offset;
}

ll count_ends_in_reach(const vector<interval>& reach, ll start_pos, ll target_balance)
{
    if (reach.empty())
        return 0;

    ll reach_left = reach.front().first;
    ll reach_right = reach.back().second;
    ll answer = 0;
    int reach_id = 0;

    for (int segment_id = 0; segment_id < t_segments_count; segment_id++)
    {
        if (t_segment_pos[segment_id + 1] <= start_pos || t_segment_pos[segment_id + 1] < reach_left)
            continue;

        if (t_segment_pos[segment_id] > reach_right)
            break;

        ll end_pos = find_end_position_in_segment(segment_id, target_balance);
        if (end_pos < 0)
            continue;

        if (end_pos <= start_pos) continue;
        if (end_pos < reach_left || end_pos > reach_right)
            continue;
        while (reach_id < (int)reach.size() && reach[reach_id].second < end_pos)
            reach_id++;

        if (reach_id < (int)reach.size() && reach[reach_id].first <= end_pos)
            answer++;
    }

    return answer;
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    read_word(s_segments);
    read_word(t_segments);

    init_s_data();
    init_t_data();

    ll answer = 0;

    // grupujemy starty po segmentach t, start_pos = segment_start + offset
    // liczymy reach i dopuszczalne końceĘ
    for (int segment_id = 0; segment_id < t_segments_count; segment_id++)
    {
        ll segment_start = t_segment_pos[segment_id];
        ll segment_length = t_segments[segment_id].cnt;
        int segment_dir = t_segments[segment_id].dir;
        ll segment_balance = t_segment_balance[segment_id];

        auto evaluate_start = [&](ll offset)
        {
            ll start_pos = segment_start + offset;
            ll start_balance = segment_balance + (ll)segment_dir * offset;
            ll target_balance = start_balance - s_total_balance;

            vector<interval> reach = evaluate_reach(start_pos);
            return count_ends_in_reach(reach, start_pos, target_balance);
        };

        for (ll offset = 0; offset < segment_length; offset++)
            answer += evaluate_start(offset);
    }

    cout << answer << endl;
    return 0;
}