static double minprec = -1;
    static Operator* minrator = new Operator("<minimum-precedence-operator>", minprec, FixityT::Infix, AssocT::Noassoc);

    Operator* Parser::get_op(Token t)
    {
        auto it = m_Operators.find(t.Value);
        if (it == m_Operators.end())
            return nullptr;

        return it->second;
    }

    Operator* Parser::srator(ExprStack& stack)
    {
        if (stack.empty())
        {
            return minrator;
        }

        return std::get<0>(stack.top());
    }

    bool Parser::is_prefix(Operator* op)
    {
        return op->Fixity == FixityT::Prefix;
    }

    bool Parser::noparens(Operator* a, Operator* b, AssocT side)
    {
        auto pi = a->Precedence;
        auto fi = a->Fixity;
        auto ai = a->Assoc;
        auto po = b->Precedence;
        auto fo = b->Fixity;
        auto ao = b->Assoc;

        if (pi > po) return true;
        if (side == AssocT::Left)
        {
            if (fi == FixityT::Postfix) return true;
            if (fi == FixityT::Infix && ai == AssocT::Left) return (fo == FixityT::Infix && ao == AssocT::Left);
        }
        else if (side == AssocT::Right)
        {
            if (fi == FixityT::Postfix) return true;
            if (fi == FixityT::Infix && ai == AssocT::Right) return (fo == FixityT::Infix && ao == AssocT::Right);
        }
        else if (side == AssocT::Noassoc)
        {
            if (fi == FixityT::Infix && fo == FixityT::Infix) return ai == ao;
            return fi == fo;
        }

        return false;
    }

    Expr* Parser::parse_prefix(ExprStack& stack, OpList& prefixes)
    {
        Operator* op;
        if (!(op = get_op(Peek())))
        {
            Expr* atom = ParseAtom();
            if (!atom)
            {
                std::cout << "Atom expected" << std::endl;
                return nullptr;
            }
            return parse_postfix(stack, atom, prefixes);
        }
        else
        {
            if (is_prefix(op))
            {
                Next();
                prefixes.push_back(op);
                return parse_prefix(stack, prefixes);
            }
            else
            {
                std::cout << "Not prefix op!" << std::endl;
            }
        }
        if (Peek().Value == " Epsilon ")
        {
            std::cout << "Premature EOE" << std::endl;
        }
        return nullptr;
    }

    Expr* Parser::parse_postfix(ExprStack& stack, Expr* exp, OpList& ls)
    {
        Operator* irator = get_op(Peek());
        if (irator)
        {
            if (irator->Fixity == FixityT::Postfix)
            {
                if (noparens(srator(stack), irator, AssocT::Left))
                {
                    if (stack.empty())
                    {
                        std::cout << "IMPOSSIBLE" << std::endl;
                        return nullptr;
                    }
                    else
                    {
                        auto& tpl = stack.top();
                        stack.pop();
                        Operator* op = std::get<0>(tpl);
                        Expr* e2 = std::get<1>(tpl);
                        auto prefxes = std::get<2>(tpl);
                        return parse_postfix(stack, new BinExpr(e2, exp, op), irator);
                    }
                }
                else if (noparens(irator, srator(stack), AssocT::Right))
                {
                    return parse_postfix(stack, new UryExpr(exp, irator), ls);
                }
                else
                {
                    std::cout << "NON assoc!" << std::endl;
                    return nullptr;
                }
            }
            else if (irator->Fixity == FixityT::Infix)
            {
                if (noparens(srator(stack), irator, AssocT::Left))
                {
                    if (stack.empty())
                    {
                        std::cout << "IMPOSSIBLE" << std::endl;
                        return nullptr;
                    }
                    else
                    {
                        auto& tpl = stack.top();
                        stack.pop();
                        Operator* op = std::get<0>(tpl);
                        Expr* e2 = std::get<1>(tpl);
                        return parse_postfix(stack, new BinExpr(e2, exp, op), irator);
                    }
                }
            }
        }
    }