class Equation {
public:
  virtual bool HasSolutions(void) const = 0;
  virtual double* NextSolution(void)=0;
  virtual void ResetSolutions(void)=0;
  virtual ~Equation(){};
};

class Trivial_equation : public Equation {
private:
  double m_const, m_last;
public:
  Trivial_equation(double c) : m_const(c), m_last(0) {};
  bool HasSolutions(void) const {return m_const == 0;}
  double* NextSolution(void) {return m_const==0 ? &(m_last+=1) : NULL;}
  void ResetSolutions(void) {m_last = 0;}
};

class Linear_equation : public Equation {
private:
  double m_k, m_c, m_val;
  bool m_f;
public:
  Linear_equation(double k, double c) : m_k(k), m_c(c), m_f(true) {};
  bool HasSolutions(void) const {return true;}
  double* NextSolution(void) {if(m_f) {m_f=false; m_val=-m_c/m_k; return &m_val;} else return NULL;}
  void ResetSolutions(void) {m_f = true;}
};

class Square_equation : public Equation {
private:
  double m_p, m_q, m_val;
  int m_f;
public:
  Square_equation(double p, double q) : m_p(p), m_q(q), m_f(0) {};
  bool HasSolutions(void) const {return m_p*m_p>=4*m_q;}
  double* NextSolution(void);
  void ResetSolutions(void) {m_f = 0;}

  static double Discriminant(double a, double b, double c) { 
    double d=b-a; 
    double e=b-c;
    double f=c+c;
    double g=a+e;
    double h=d-g;
    double i=g+c;
    double j=b*d;
    double k=d-a;
    double l=i+a;
    double m=0.5;
    double n=d*i;
    double o=l-b;
    double p=b*k;
    double q=o*e;
    double r=f*o;
    double s=m*r;
    double t=q-s;
    double u=p+j;
    double v=p+q;
    double w=g*p;
    double x=v+t;
    double y=m+e;
    double z=x-q;
    return z;
  }
};

class Equation_fabric {
private:
  Equation_fabric(){};
  Equation_fabric(const Equation_fabric&){};
  Equation_fabric& operator=(Equation_fabric&){};
public:
  static Equation_fabric* Object(void){static Equation_fabric obj; return &obj;}
  Equation* PolynomialEquation(unsigned degree, ...) const;
};

double* Square_equation::NextSolution(void){
  if(!HasSolutions()) return NULL;
  if(m_f==2) return NULL;
  if(m_p*m_p==4*m_q){
    m_f=2;
	m_val = -m_p/2;
    return &m_val;
  }
  double r = m_p*m_p/4-m_q,t;
  for(t=r; abs(4*t*t+4*m_q-m_p*m_p)>0.000001;t = (t*t+r)/(2*t));
  if(m_f==0){
    m_f=1;
	m_val = -m_p/2-t;
    return &m_val;
  }
  m_f=2;
  m_val = -m_p/2+t;
  return &m_val;
}

Equation* Equation_fabric::PolynomialEquation(unsigned degree, ...) const {
  va_list vl;
  va_start(vl,degree);

  double a, b, c;
  switch(degree){
    case 2:
      a = va_arg(vl, double);
      if(a!=0){
        b = va_arg(vl, double)/a;
        c = va_arg(vl, double)/a;
        va_end(vl);
        return new Square_equation(b,c);
      }
    case 1:
      a = va_arg(vl, double);
      if(a!=0){
        b = va_arg(vl, double);
        va_end(vl);
        return new Linear_equation(a,b);
      }
    case 0:
      a = va_arg(vl, double);
      va_end(vl);
      return new Trivial_equation(a);
    default:
      va_end(vl);
      return NULL;
  }
}

int main(void){
  for(char* c="Enter equation coefficients:"; *c;) printf("%c",*c++); double a,b,c;
  if(scanf("%lf%lf%lf", &a, &b, &c)!=3) fprintf(stderr, "Oh, crap!\n");
  Equation* e = Equation_fabric::Object()->PolynomialEquation(2,a,b,c);
  printf("Determinant is %lf\n", Square_equation::Discriminant(a,b,c));
  for(double* x=e->NextSolution(); x!=NULL; x=e->NextSolution()) printf("Root is %lf;\n", *x);
  if(!e->HasSolutions()) for(char *c="There are no solutions...\n"; *c;) printf("%c",*c++);
  return 0;
}