interpreter test (PL)

#include <algorithm>
#include <cstdint>
#include <iostream>
#include <utility>
#include <vector>

enum class Token : std::uint8_t {

    EVEN_VALUE,
    ODD_VALUE,
    ADD,
    MULT

};

using ValueType = int;
using OperatorType = char;
using TokenArray = std::vector<Token>;

Token valueToToken(ValueType value) {

    return (value % 2 == 0) ? (Token::EVEN_VALUE) : (Token::ODD_VALUE);

}

Token operatorToToken(OperatorType oper) {

    return (oper == '*') ? (Token::MULT) : (Token::ADD);

}

Token mult(Token lhs, Token rhs) {

    return (lhs == Token::ODD_VALUE and rhs == Token::ODD_VALUE) ? (Token::ODD_VALUE) : (Token::EVEN_VALUE);

}

Token add(Token lhs, Token rhs) {

    return (lhs == rhs) ? (Token::EVEN_VALUE) : (Token::ODD_VALUE);

}

void loadTokens(TokenArray& tokens) {

    ValueType value;
    OperatorType oper;

    while(std::cin >> value >> oper) {

        tokens.push_back(valueToToken(value));

        if(oper == '=') {

            break;

        } else {

            tokens.push_back(operatorToToken(oper));

        }

    }

}

void parseMult(TokenArray& tokens) {

    TokenArray result;

    for(auto iterator = tokens.begin(); iterator != tokens.end(); ++iterator) {

        if(*iterator == Token::MULT) {

            // Get and remove last pushed value
            Token lastValue = result.back();
            result.pop_back();

            // Increment iterator to next value
            ++iterator;

            // Add new value
            result.push_back(mult(lastValue, *iterator));

        } else {

            result.push_back(*iterator);

        }

    }

    tokens = std::move(result);

}

void parseAdd(TokenArray& tokens) {

    // Remove +- operators
    tokens.erase(std::remove(tokens.begin(), tokens.end(), Token::ADD), tokens.end());

    while(tokens.size() > 1) {

        // Get and remove last value
        Token lastValue = tokens.back();
        tokens.pop_back();

        // Add new value
        tokens.back() = add(lastValue, tokens.back());

    }

}

void test() {

    TokenArray tokens;

    loadTokens(tokens);

    parseMult(tokens);
    parseAdd(tokens);

    std::cout << ((tokens.at(0) == Token::EVEN_VALUE) ? ("TAK") : ("NIE")) << '\n';

}

int main() {

    int tests;
    std::cin >> tests;

    while(tests--) {
        test();
    }

}