void checkRawAccess() {
     Printf("Raw access+++++++++++++++++++++++++++\n");
     VD data = { 0, 1, 1,
                 2, 3, 2,
                 1, 3, 2,
                 4, 2, 2};
     Matrix m(3, data);
     print(m);
     
     double expected, test;
     size_t rows = data.size() / 3;
     // check read
     for (int i = 0; i < rows; i++) {
         for (int j = 0; j < 3; j++) {
             expected = data[i * 3 + j];
             test = m(i, j);
             unitpp::assert_eq(spf("Expected value not equal to readen at row: %i, col: %i", i, j), test, expected);
         }
     }
     
     // check write
     int val = 0;
     for (int i = 0; i < rows; i++) {
         for (int j = 0; j < 3; j++) {
             m(i, j) = val++;
         }
     }
     VD testVector;
     m.rowPackedCopy(testVector);
     for (int i = 0; i < testVector.size(); i++) {
         test = testVector[i];
         unitpp::assert_eq(spf("Value found: %i, but was expected: %i", test, i), test, i);
     }
 }

 double doExec() {
     
     if (!loadTestData()) {
         std::cerr << "Failed to load test data" << std::endl;
         return -1;
     }
     
     //
     // Start solution testing
     //
     double score = 0, sse;
     int scenario = 0;
     for (int i = 0; i < subsetsNum; i++) {
         scenario = i % 3;
         generateTestData(scenario, i);
         VD res = test->predict(0, scenario, DTrain, DTest);
         
         Assert(groundTruth.size() == res.size(), "Expected results count not equal to found. Expected: %lu, but found: %lu", groundTruth.size(), res.size());
         sse = 0;
         for (int j = 0; j < res.size(); j++) {
             double e = res[j] - groundTruth[j];
             sse += e * e;
         }
         // calculate score
         double s = 1000000 * fmax(0, 1.0 - sse/sse0);
         Printf("%i.) Score = %f, sse: %f, sse0: %f\n", i, s, sse, sse0);
         score += s;
     }
     return score / subsetsNum;
 }

int main() {

  const int m = 4;
  const int n = 3;  
  DOUBLE _A[m][n] = {
    { 6, -1, 0 },
    { -1, -5, 0 },
    { 1, 5, 1 },
    { -1, -5, -1 }
  };
  DOUBLE _b[m] = { 10, -4, 5, -5 };
  DOUBLE _c[n] = { 1, -1, 0 };
  
  VVD A(m);
  VD b(_b, _b + m);
  VD c(_c, _c + n);
  for (int i = 0; i < m; i++) A[i] = VD(_A[i], _A[i] + n);

  LPSolver solver(A, b, c);
  VD x;
  DOUBLE value = solver.Solve(x);
  
  cerr << "VALUE: "<< value << endl;
  cerr << "SOLUTION:";
  for (size_t i = 0; i < x.size(); i++) cerr << " " << x[i];
  cerr << endl;
  return 0;
}

 LPSolver(const VVD &A, const VD &b, const VD &c) :
  m(b.size()), n(c.size()),
  N(n + 1), B(m), D(m + 2, VD(n + 2)) {
  for (int i = 0; i < m; i++) for (int j = 0; j < n; j++)
    D[i][j] = A[i][j];
  for (int i = 0; i < m; i++) { B[i] = n + i; D[i][n] = -1;
    D[i][n + 1] = b[i]; }
  for (int j = 0; j < n; j++) { N[j] = j; D[m][j] = -c[j]; }
  N[n] = -1; D[m + 1][n] = 1; }

void MLComputeTest::dotProduct_benchmark_vector()
{
    VD data;
    data.resize(10000);
    std::iota(data.begin(), data.end(), 1);
    QBENCHMARK
    {
        MLCompute::dotProduct(data, data);
    }
}

void MLComputeTest::correlation_benchmark_parallel()
{
    VD data;
    data.resize(10000);
    std::iota(data.begin(), data.end(), 1);
    QBENCHMARK
    {
        correlation_parallel(data, data);
    }
}

void MLComputeTest::correlation_benchmark_alternative()
{
    VD data;
    data.resize(10000);
    std::iota(data.begin(), data.end(), 1);
    QBENCHMARK
    {
        correlation_helper(data, data);
    }
}

void MLComputeTest::stdev_benchmark()
{
    VD data;
    data.resize(10000);
    std::iota(data.begin(), data.end(), 1);
    QBENCHMARK
    {
        MLCompute::stdev(data);
    }
}

 LPSolver(const VD &b, const VD &c) : 
   m(b.size()), n(c.size()), N(n+1), B(m), D(m+2, VD(n+2)) {
   for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) D[i][j] = AA[i][j];
   for (int i = 0; i < m; i++) { B[i] = n+i; D[i][n] = -1; D[i][n+1] = b[i]; }
   for (int j = 0; j < n; j++) { N[j] = j; D[m][j] = -c[j]; }
   N[n] = -1; D[m+1][n] = 1;
   /*for (int i = 0; i < m+2; i++) {
    for (int j = 0; j < n+2; j++){ cout<<D[i][j]<<" ";}
    cout<<endl;
   }*/
 }

int main() {
  int n;
  cin >> n;
  VD arr(n+1);
  for (int i = 0; i <= n; i++) cin >> arr[i];
  
  VD ans = roots(poly(arr));
  cout << ans.size() << endl;
  for (int i = 0; i < ans.size(); i++) printf("%.4f\n", ans[i]);
  
  return 0;
}

void MLComputeTest::min_benchmark()
{
    VD data;
    data.reserve(10000);
    for (int i = 0; i < 10000; ++i) {
        data.append(-10000 + qrand());
    }
    QBENCHMARK
    {
        MLCompute::min(data.size(), data.data());
    }
}

VD generateVoronoi(int ** setPoints, int numberofPoints){
	VD vd;

	int i = 0;
	for(i = 0; i < numberofPoints * 3; i+=3){
		Site_2 p(Point_2((*setPoints)[i], (*setPoints)[i + 1]));
		vd.insert(p);
	}

	return vd;

}

 void set(VVD & A, VD & B, VD & C) {
   n = C.size();
   m = A.size();
   left.resize(m);
   up.resize(n);
   pos.resize(n);
   res.resize(n);
   status = -2;
   v = 0;
   a = A;
   b = B;
   c = C;
 }

VD roots(const poly &p) {
  if (p.is_constant()) return VD(0);
  VD critical_values = roots(p.derivative());
  critical_values.push_back(1e6);
  
  VD ans;
  double lower = -1e6;
  for (int i = 0; i < critical_values.size(); i++) {
    double upper = critical_values[i];
    if (sgn(p.eval(lower)) != sgn(p.eval(upper)))
      ans.push_back(bisect(p, lower, upper));
    
    lower = upper;
  }
  
  return ans;
}

void init(VD & t, int & n, PDD * p, PDD & a, PDD & b) {
	t.clear();
	double tmp;
	for (int i = 0; i < n; ++i) {
		scanf("%lf", &tmp);
		t.PB(tmp);
	}
	std::sort(t.begin(), t.end());
	t.erase(std::unique(t.begin(), t.end()), t.end());
	n = t.size();
	for (int i = 0; i < n; ++i) {
		p[i] = at(a, b, t[i]);
	}
}

 virtual QStringList
 formatFromPixelCoordinate( const VD & pix ) override
 {
     CARTA_ASSERT( pix.size() >= 2 );
     QStringList res;
     res.append( QString::number( pix[0] ) );
     res.append( QString::number( pix[1] ) );
     return res;
 }

DotNode* GraphKMeans::getNextMean(const vector<DotNode*>& means, ConnectedDotGraph& g)
{
	VD minDist;
	for (int i = 0; i < (int)g.nodes.size(); i++)
	{
		double minD = 123456789.0;
		for (int j = 0; j < (int)means.size(); j++)
		{
			double d = g.getShortestPath(g.nodes[i], means[j], true);
			minD = min(minD, d);
		}

		minDist.push_back(Sqr2(minD));
	}

	int p = randWithProbability(minDist);
	if (minDist[p] < 1e-6) return NULL;

	return g.nodes[p];
}

void MLComputeTest::dotProduct_benchmark_arrays()
{
    VD data;
    data.resize(10000);
    std::iota(data.begin(), data.end(), 1);
    QBENCHMARK
    {
        MLCompute::dotProduct(data.size(), data.data(), data.data());
    }
}

void MLComputeTest::dotProduct_benchmark_inner_product()
{
    VD data;
    data.resize(10000);
    std::iota(data.begin(), data.end(), 1);
    QBENCHMARK
    {
        std::inner_product(data.constBegin(), data.constEnd(), data.constBegin(), 0);
    }
}

void MLComputeTest::mean_benchmark_alternative()
{
    VD data;
    data.resize(10000);
    std::iota(data.begin(), data.end(), 1);
    QBENCHMARK
    {
        (void)(std::accumulate(data.constBegin(), data.constEnd(), 0) / data.size());
    }
}