// similar a https://omegaup.com/arena/problem/Calculadora-de-expresiones-aritm
#include <iostream>
#include <map>
#include <string>
#include <ctype.h>

std::map<char, double> simbolos = {
   { 'a', 3.14 },
   { 'b', 2.71 },
   { 'c', 1.23 },
   { 'd', 4.56 },
   { 'e', 7.89 }
};

struct expresion {
   virtual ~expresion( ) = default;
   virtual double evalua( ) const = 0;
};

struct expresion_termino : expresion {
   char variable;

   expresion_termino(double v)
   : variable(v) {
   }

   double evalua( ) const {
      return simbolos[variable];
   }
};

struct expresion_unaria : expresion {
   char operador;
   expresion* ex;

   expresion_unaria(char c, expresion* e)
   : operador(c), ex(e) {
   }

   double evalua( ) const {
      return (operador == '+' ? +1 : -1) * ex->evalua( );
   }
};

struct expresion_binaria : expresion {
   expresion* izq;
   char operador;
   expresion* der;

   expresion_binaria(expresion* i, char c, expresion* d)
   : izq(i), operador(c), der(d) {
   }

   double evalua( ) const {
      if (operador == '+') {
         return izq->evalua( ) + der->evalua( );
      } else if (operador == '-') {
         return izq->evalua( ) - der->evalua( );
      } else if (operador == '*') {
         return izq->evalua( ) * der->evalua( );
      } else if (operador == '/') {
         return izq->evalua( ) / der->evalua( );
      }
   }
};

void espera(const char*& p, char c) {
   if (*p++ != c) {
      throw std::runtime_error("ERROR");
   }
}

int precedencia(char c) {
   return (c == '+' || c == '-' ? 1 : (c == '*' || c == '/' ? 2 : -1));
}

expresion* parsea_expresion(const char*&);

expresion* parsea_expresion_primaria(const char*& p) {
   if (isalpha(*p)) {
      return new expresion_termino(*p++);
   } else {
      espera(p, '(');
      auto ex = parsea_expresion(p);
      espera(p, ')');
      return ex;
   }
}

expresion* parsea_expresion_unaria(const char*& p) {
   if (*p == '+' || *p == '-') {
      char c = *p++;
      return new expresion_unaria(c, parsea_expresion_unaria(p));
   } else {
      return parsea_expresion_primaria(p);
   }
}

expresion* parsea_expresion_binaria(const char*& p, int prec) {
   expresion* ex = parsea_expresion_unaria(p);
   while (precedencia(*p) >= prec) {
      char c = *p++;
      ex = new expresion_binaria(ex, c, parsea_expresion_binaria(p, precedencia(c) + 1));
   }
   return ex;
}

expresion* parsea_expresion(const char*& p) {
   return parsea_expresion_binaria(p, 0);
}

expresion* parsea(const char*& p) {
   expresion* ex = parsea_expresion(p);
   espera(p, '\0');
   return ex;
}

int main( ) try {
   std::string s = "a+b+c*(d+e)/a+-b+a/a/b";
   const char* p = &s[0];
   expresion* ex = parsea(p);
   std::cout << ex->evalua( ) << "\n";
} catch (const std::exception& ex) {
   std::cout << ex.what( );
}