#include <vector>
#include <iostream>
#include <algorithm>
#include <stack>
#include <charconv>
#include <string>
#include <cmath>


using namespace std;
 
int evaluateBoolExpr(string s)
{
    int n = s.length();
 
    // Traverse all operands by jumping
    // a character after every iteration.
    for (int i = 0; i < n; i += 2) {
        // If operator next to current operand
        // is AND.
        if (s[i + 1] == '&') {
            if (s[i + 2] == '0'|| s[i] == '0')
                s[i + 2] = '0';
            else
                s[i + 2] = '1';
        }
 
        // If operator next to current operand
        // is OR.
        else if (s[i + 1] == '|') {
            if (s[i + 2] == '1'|| s[i] == '1')
                s[i + 2] = '1';
            else
                s[i + 2] = '0';
        }
 
        // If operator next to current operand
        // is XOR (Assuming a valid input)
        else if (s[i + 1] == '^') {
            if (s[i + 2] == s[i])
                s[i + 2] = '0';
            else
                s[i + 2] = '1';
        }
    }
    return s[n - 1] -'0';
}
 

int main() {
     string str;
    long unsigned t {};
    int arr[5] = {1, 2, 3, 4, 5};

     getline( cin, str);

     cin >> t;

    while (t--) {
         cin >> arr[0] >> arr[1] >> arr[2] >> arr[3] >> arr[4];
         cout <<  evaluateBoolExpr(str) << '\n';
    }
}

#include <iostream>
#include <string>
#include <stack>
#include <cctype>
#include <iomanip>

using ITR = std::string::iterator;

bool L4(ITR& it, ITR itend, std::string& post);

bool l1(ITR& it, ITR itend, std::string& post) {
	if (it != itend) {
		if (*it == '0' || *it == '1' || (*it >= 'A' && *it <= 'E'))
			post += *it++;
		else if (*it == '(') {
			if (!L4(++it, itend, post))
				return false;

			if (*it != ')')
				return false;

			++it;
		} else
			return false;

		return true;
	}

	return false;
}

bool L2(ITR& it, ITR itend, std::string& post) {
	if (!l1(it, itend, post))
		return false;

	while (*it == '&') {
		const auto op {*it};

		if (!l1(++it, itend, post))
			return false;

		post += op;
	}

	return true;
}

bool L3(ITR& it, ITR itend, std::string& post) {
	if (!L2(it, itend, post))
		return false;

	while (*it == '|') {
		const auto op {*it};

		if (!L2(++it, itend, post))
			return false;

		post += op;
	}

	return true;
}

bool L4(ITR& it, ITR itend, std::string& post) {
	if (!L3(it, itend, post))
		return false;

	while (*it == '^') {
		const auto op {*it};

		if (!L3(++it, itend, post))
			return false;

		post += op;
	}

	return true;
}

bool parse(ITR& it, ITR itend, std::string& post) {
	return L4(it, itend, post) && it == itend;
}

bool eval(const std::string& rpn, const int args[5]) {
	std::stack<int> stk;

	for (unsigned ch : rpn) {
		if (std::isdigit(ch))
			stk.push(ch - '0');
		else if (std::isalpha(ch))
			stk.push(args[ch - 'A']);
		else
			if (stk.size() >= 2) {
				const auto i1 {stk.top()};
				stk.pop();
				const auto i2 {stk.top()};
				stk.pop();

				switch (ch) {
					case '|':
						stk.push(i1 | i2);
						break;

					case '&':
						stk.push(i1 & i2);
						break;

					case '^':
						stk.push(i1 ^ i2);
						break;

					default:
						return (std::cout << "Something went wrong!\n"), 0;
				}
			} else
				return (std::cout << "Something went wrong!\n"), 0;
	}

	if (stk.size() != 1)
		return (std::cout << "Something went wrong!\n"), 0;
	else
		return stk.top();
}

int main() {
	std::string str, rpn;
	unsigned t {};

	int arr[5] {};

	std::getline(std::cin, str);

	ITR it {str.begin()};

	if (!parse(it, str.end(), rpn))
		return (std::cout << "Bad expression\n"), 1;

	std::cin >> t;

	while (t--) {
		std::cin >> arr[0] >> arr[1] >> arr[2] >> arr[3] >> arr[4];
		std::cout << "Evaluates as " << std::boolalpha << eval(rpn, arr) << '\n';
	}
}