#include <string>
#include <iostream>
#include <complex>
#include <stdexcept>
#include <type_traits>
#include <cmath>
template < typename C, C beginVal, C endVal>
class Iterator {
  typedef typename std::underlying_type<C>::type val_t;
  int val;
public:
  Iterator(const C & f) : val(static_cast<val_t>(f)) {}
  Iterator() : val(static_cast<val_t>(beginVal)) {}
  Iterator operator++() {
    ++val;
    return *this;
  }
  C operator*() { return static_cast<C>(val); }
  Iterator begin() { return *this; } //default ctor is good
  Iterator end() {
      static const Iterator endIter=++Iterator(endVal); // cache it
      return endIter;
  }
  bool operator!=(const Iterator& i) { return val != i.val; }
};




int main()
{

   enum BosonPolarizationType   { LEFT, RIGHT, MINUS0, PLUS0 };
   enum NucleonPolarizationType { PLUS, MINUS };
   
   typedef Iterator<BosonPolarizationType,   BosonPolarizationType::LEFT,       BosonPolarizationType::PLUS0> BosonPolarizationTypeIterator;
   typedef Iterator<NucleonPolarizationType, NucleonPolarizationType::PLUS, NucleonPolarizationType::MINUS> NucleonPolarizationTypeIterator;
   
   std::string slabmdak, slabmda1, slabmda2,ssign;
   std::ostringstream liter;
   int ilambdak, ilambda1, ilambda2, sign;
   
   for (BosonPolarizationType lambda_k : BosonPolarizationTypeIterator() )
      for (NucleonPolarizationType lambda_1 : NucleonPolarizationTypeIterator() )
         for (NucleonPolarizationType lambda_2 : NucleonPolarizationTypeIterator() )
         {
            liter.str("");
            liter.clear();
            switch (lambda_k)
            {
               case (LEFT):
                 slabmdak = "eL";
                 liter << "f_{+";
                 ilambdak = -2;
                 sign = -1;
                 break;
               case (RIGHT):
                 slabmdak = "eR";
                 liter << "f_{-";
                 ilambdak = 2;
                 sign = -1;
                 break;
               case (MINUS0):
                 slabmdak = "e-";
                 liter << "f^{(-)}_{0";
                 ilambdak = 0;
                 sign = 1;
                 break;
               case (PLUS0):
                 slabmdak = "e+";
                 liter << "f^{(+)}_{0";
                 ilambdak = 0;
                 sign = 1;
                 break;
            }
            
            switch (lambda_2)
            {
               case (MINUS):
                 slabmda2 = "-1/2";
                 ilambda2 = -1;
                 break;
               case (PLUS):
                 slabmda2 = "+1/2";
                 ilambda2 = 1;
                 break;
            }
            
            switch (lambda_1)
            {
               case (MINUS):
                 slabmda1 = "-1/2";
                 ilambda1 = -1;
                 break;
               case (PLUS):
                 slabmda1 = "+1/2";
                 ilambda1 = 1;
                 break;
            }
            
            int lambda = ilambdak - ilambda1;
            int mu = -ilambda2;
            
            if (abs(ilambda1+ilambda2)/2 == 1)
              sign *= -1;
           
           int phi =  ilambdak - ilambda1 - ilambda2;
           
           switch (lambda_k)
           {
              case (LEFT):
              case (RIGHT):
                liter << abs(lambda) << "}";
                break;
              case (MINUS0):
              case (PLUS0):
                if (lambda > 0) liter<<"+";
                else liter<<"-";
                liter << "}";
                break;
           }
           
           int factor = 1;
           int itemp;
           if (abs(lambda) < abs(mu))
           {
			 factor = pow(-1, lambda - mu);
             itemp = lambda;
             lambda = mu;
             mu = itemp;
		   }
           if (lambda<0)
           {
              itemp = lambda;
              lambda = -mu;
              mu = -itemp;
           }
           if (abs(lambda) < abs(mu))
           {
			 factor = pow(-1, lambda - mu);
             itemp = lambda;
             lambda = mu;
             mu = itemp;
		   }
		   if (lambda<0)
           {
              factor = pow(-1, lambda - mu);
             itemp = lambda;
             lambda = mu;
             mu = itemp;
           }
           sign *= factor;
           
           ssign = sign>0?"+":"-";
         
         
           
           std::cout << "F^{" << slabmdak << "}_{" << slabmda2 << slabmda1 << "}=" << ssign << liter.str() << "d_{" << lambda << "," << mu <<"}*EXP[" << phi/2 << "*i*phi]" << std::endl;
            
         }
   
   
   
   
   
}