/*
ID: espr1t
TASK: 
KEYWORDS: 
*/

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <string>

using namespace std;
FILE* in = stdin; FILE* out = stdout;

const int MAX = 500005;
const int BUCKET_SIZE = 5005;
const int NUM_BUCKETS = MAX / BUCKET_SIZE + 1;

int n;
int a[MAX];
int len;
char num[MAX];
int bucket[NUM_BUCKETS][MAX + 1];

void update(int tree[MAX], int idx, int delta) {
    for (idx = idx + 1; idx <= MAX; idx += (idx & -idx))
        tree[idx] += delta;
}

int query(int tree[MAX], int idx) {
    int sum = 0;
    for (; idx > 0; idx -= (idx & -idx))
        sum += tree[idx];
    return sum;
}

int query(int tree[MAX], int left, int right) {
    return query(tree, right + 1) - query(tree, left);
}

int fastPow(int dig, int pwr) {
    int ret = 1;
    while (pwr) {
        if (pwr & 1)
            ret = (ret * dig) % 10;
        dig = (dig * dig) % 10;
        pwr >>= 1;
    }
    return ret;
}

int solve(int idx, int pos) {
    int pwr = 0;

    int lastBucket = pos / BUCKET_SIZE;
    for (int b = 0; b < lastBucket; b++) {
        pwr += query(bucket[b], idx + 1, MAX - 1);
        if (b == 0)
            pwr -= (a[0] > idx);
    }
    
    int startIdx = max(1, lastBucket * BUCKET_SIZE);
    for (int i = startIdx; i <= pos; i++) {
        if (a[i] > idx)
            pwr++;
    }

    update(bucket[pos / BUCKET_SIZE], a[pos], -1);
    update(bucket[0], a[pos], +1);
    update(bucket[0], a[0], -1);
    update(bucket[pos / BUCKET_SIZE], a[0], +1);
    swap(a[0], a[pos]);

    return ((num[idx] - '0') * fastPow(2, pwr)) % 10;
}

int dummy(int idx, int pos) {
    int dig = num[idx] - '0';
    for (int i = 1; i <= pos; i++) {
        dig = (a[i] > idx ? (dig + dig) % 10 : dig);
    }
    swap(a[0], a[pos]);
    return dig;
}

int main(void) {
	in = fopen("sequence.in", "rt"); out = fopen("sequence.out", "wt");
	
	fscanf(in, "%s", num);
	len = (int)strlen(num);
	reverse(num, num + len);
	
	fscanf(in, "%d", &n);
	for (int i = 0; i < n; i++) {
	    fscanf(in, "%d", &a[i]);
	    a[i] = min(a[i], len + 1);
	    update(bucket[i / BUCKET_SIZE], a[i], +1);
    }
	
	int numQueries;
	fscanf(in, "%d", &numQueries);
	for (int i = 0; i < numQueries; i++) {
	    int idx, pos;
	    fscanf(in, "%d %d", &idx, &pos);
	    idx--, pos--;
	    int ret = solve(idx, pos);
	    fprintf(out, "%d\n", ret);
	    //fprintf(stdout, "%d\n", ret);
    }
	
	return 0;
}