#include "pch.h"
#include <iostream>
#include <vector>

//variant 10

using namespace std;

const double EPSX = 0.0001;
const double EPSY = 0.0001;
const double EPS = 0.0001;

double getY(double x, double y)
{
   //return (100 * (y - x) * (y - x) + (1 - x) * (1 - x));
   //return ((100 * (y - x * x) * (y - x * x)) + (1 - x) * (1 - x));
   return (1 / (1 + (x - 3)*(x - 3) + (y - 2)*(y - 2)) + 2 / (1 + (x - 2)*(x - 2) + (y - 2)*(y - 2)));
}

double fibbonacix(double a, double b, double y)
{
   double x1, x2, Fn, Fn1, Fn2, F, aold, bold, x, firstint;

   Fn2 = floor(abs(b - a) / EPSX);
   vector<int> Fib(0);
   int i = 1;
   Fib.push_back(1);
   Fib.push_back(1);
   while (Fib[i] < Fn2)
   {
      Fib.push_back(Fib[i] + Fib[i - 1]);
      i++;
   }
   i -= 2;

   firstint = a - b;

   while (i >= 2)
   {
      Fn2 = Fib[i];
      Fn1 = Fib[i - 1];
      Fn = Fib[i - 2];
      x1 = a + Fn / Fn2 * (b - a);
      x2 = a + Fn1 / Fn2 * (b - a);

      aold = a;
      bold = b;

      if (getY(x1, y) < getY(x2, y))
         b = x2;
      if (getY(x1, y) > getY(x2, y))
         a = x1;
      if (getY(x1, y) == getY(x2, y))
      {
         a = x1;
         b = x2;
      }
      i--;
   }

   return (a + Fib[0] / Fib.back() * firstint);
}

double fibbonaciy(double a, double b, double x)
{
   double y1, y2, Fn, Fn1, Fn2, F, aold, bold, y, firstint;

   Fn2 = floor(abs(b - a) / EPSY);

   vector<int> Fib(0);
   int i = 1;
   Fib.push_back(1);
   Fib.push_back(1);
   while (Fib[i] < Fn2)
   {
      Fib.push_back(Fib[i] + Fib[i - 1]);
      i++;
   }
   i -= 2;

   firstint = a - b;

   while (i >= 2)
   {
      Fn2 = Fib[i];
      Fn1 = Fib[i - 1];
      Fn = Fib[i - 2];
      y1 = a + Fn / Fn2 * (b - a);
      y2 = a + Fn1 / Fn2 * (b - a);

      aold = a;
      bold = b;

      if (getY(x, y1) < getY(x, y2))
         b = y2;
      if (getY(x, y1) > getY(x, y2))
         a = y1;
      if (getY(x, y1) == getY(x, y2))
      {
         a = y1;
         b = y2;
      }
      i--;
   }

   return (a + Fib[0] / Fib.back() * firstint);
}

void intervalx(double x, double y, double *left, double *right, double delta)
{
   int k = 0;
   double h, x1 = x, x0 = x;

   if (getY(x, y) >= getY(x + delta, y))
   {
      h = delta;
      x1 = x + delta;
   }
   if (getY(x, y) > getY(x - delta, y))
   {
      h = -delta;
      x1 = x - delta;
   }
   k++;

   while (getY(x, y) > getY(x1, y))
   {
      k++;
      h *= 2;
      x0 = x;
      x = x1;
      x1 = x + h;
   }
   *left = x0;
   *right = x1;
}

void intervaly(double x, double y, double *left, double *right, double delta)
{
   int k = 0;
   double h, y1 = y, y0 = y;

   if (getY(x, y) >= getY(x, y + delta))
   {
      h = delta;
      y1 = y + delta;
   }
   if (getY(x, y) > getY(x, y - delta))
   {
      h = -delta;
      y1 = y - delta;
   }
   k++;

   while (getY(x, y) > getY(x, y1))
   {
      k++;
      h *= 2;
      y0 = y;
      y = y1;
      y1 = y + h;
   }

   *left = y0;
   *right = y1;
}

void Gauss(double *x0, double *y0, double delta)
{
   double x1, x, y1, y, left, right;
   int i = 0;
   y1 = *y0;
   x1 = *x0;
   do
   {
      i++;
      x = x1;
      y = y1;
      intervalx(x, y, &left, &right, delta);
      x1 = fibbonacix(left, right, y);
      intervaly(x1, y, &left, &right, delta);
      y1 = fibbonaciy(left, right, x1);
   } while (abs(getY(x, y) - getY(x1, y1)) > EPS && abs(x-x1) > EPSX && abs(y-y1) > EPSY);
   *x0 = x;
   *y0 = y;
   cout << i << "\n";
}
//==================================================================
double fibbonacixmax(double a, double b, double y)
{
   double x1, x2, Fn, Fn1, Fn2, F, aold, bold, x, firstint;

   Fn2 = floor(abs(b - a) / EPSX);
   vector<int> Fib(0);
   int i = 1;
   Fib.push_back(1);
   Fib.push_back(1);
   while (Fib[i] < Fn2)
   {
      Fib.push_back(Fib[i] + Fib[i - 1]);
      i++;
   }
   i -= 2;

   firstint = a - b;

   while (i >= 2)
   {
      Fn2 = Fib[i];
      Fn1 = Fib[i - 1];
      Fn = Fib[i - 2];
      x1 = a + Fn / Fn2 * (b - a);
      x2 = a + Fn1 / Fn2 * (b - a);

      aold = a;
      bold = b;

      if (getY(x1, y) > getY(x2, y))
         b = x2;
      if (getY(x1, y) < getY(x2, y))
         a = x1;
      if (getY(x1, y) == getY(x2, y))
      {
         a = x1;
         b = x2;
      }
      i--;
   }

   return (a + Fib[0] / Fib.back() * firstint);
}

double fibbonaciymax(double a, double b, double x)
{
   double y1, y2, Fn, Fn1, Fn2, F, aold, bold, y, firstint;

   Fn2 = floor(abs(b - a) / EPSY);

   vector<int> Fib(0);
   int i = 1;
   Fib.push_back(1);
   Fib.push_back(1);
   while (Fib[i] < Fn2)
   {
      Fib.push_back(Fib[i] + Fib[i - 1]);
      i++;
   }
   i -= 2;

   firstint = a - b;

   while (i >= 2)
   {
      Fn2 = Fib[i];
      Fn1 = Fib[i - 1];
      Fn = Fib[i - 2];
      y1 = a + Fn / Fn2 * (b - a);
      y2 = a + Fn1 / Fn2 * (b - a);

      aold = a;
      bold = b;

      if (getY(x, y1) > getY(x, y2))
         b = y2;
      if (getY(x, y1) < getY(x, y2))
         a = y1;
      if (getY(x, y1) == getY(x, y2))
      {
         a = y1;
         b = y2;
      }
      i--;
   }

   return (a + Fib[0] / Fib.back() * firstint);
}

void intervalxmax(double x, double y, double *left, double *right, double delta)
{
   int k = 0;
   double h, x1 = x, x0 = x;

   if (getY(x, y) <= getY(x + delta, y))
   {
      h = delta;
      x1 = x + delta;
   }
   if (getY(x, y) < getY(x - delta, y))
   {
      h = -delta;
      x1 = x - delta;
   }
   k++;

   while (getY(x, y) < getY(x1, y))
   {
      k++;
      h *= 2;
      x0 = x;
      x = x1;
      x1 = x + h;
   }
   *left = x0;
   *right = x1;
}

void intervalymax(double x, double y, double *left, double *right, double delta)
{
   int k = 0;
   double h, y1 = y, y0 = y;

   if (getY(x, y) <= getY(x, y + delta))
   {
      h = delta;
      y1 = y + delta;
   }
   if (getY(x, y) < getY(x, y - delta))
   {
      h = -delta;
      y1 = y - delta;
   }
   k++;

   while (getY(x, y) < getY(x, y1))
   {
      k++;
      h *= 2;
      y0 = y;
      y = y1;
      y1 = y + h;
   }

   *left = y0;
   *right = y1;
}

void Gaussmax(double *x0, double *y0, double delta)
{
   double x1, x, y1, y, left, right;
   int i = 0;
   y1 = *y0;
   x1 = *x0;
   do
   {
      i++;
      x = x1;
      y = y1;
      intervalxmax(x, y, &left, &right, delta);
      x1 = fibbonacixmax(left, right, y);
      intervalymax(x1, y, &left, &right, delta);
      y1 = fibbonaciymax(left, right, x1);
   } while (abs(getY(x, y) - getY(x1, y1)) > EPS && abs(x - x1) > EPSX && abs(y - y1) > EPSY);
   *x0 = x;
   *y0 = y;
   cout << i << "\n";
}
//==================================================================

double difx(double x, double y, double h)
{
   return (getY(x + h, y) - getY(x, y)) / h;
}

double dify(double x, double y, double h)
{
   return (getY(x, y + h) - getY(x, y)) / h;
}

double nabs(double x, double y)
{
   return sqrt(x * x + y * y);
}

void fastdown(double *x0, double *y0, double lambda, double h)
{
   //xk+1 = xk - lambdak * grad f(xk)
   double lambdak, left, right, x = *x0, y = *y0, Sx, Sy, xk = x, yk = y;
   Sx = difx(x, y, h) / nabs(x, y);
   Sy = dify(x, y, h) / nabs(x, y);
   int i = 0;
   do
   {
      i++;
      //lambdak =
      x = xk;
      y = yk;
      xk = x - lambda * difx(x, y, h);
      yk = y - lambda * dify(x, y, h);
   } while (abs(getY(x, y) - getY(xk, yk)) > EPS && abs(x - xk) > EPSX && abs(y - yk) > EPSY);
   *x0 = x;
   *y0 = y;
   cout << i << "\n";
}

void fastdownmax(double *x0, double *y0, double lambda, double h)
{
   //xk+1 = xk - lambdak * grad f(xk)
   double lambdak, left, right, x = *x0, y = *y0, Sx, Sy, xk = x, yk = y;
   Sx = difx(x, y, h) / nabs(x, y);
   Sy = dify(x, y, h) / nabs(x, y);
   int i = 0;
   do
   {
      i++;
      //lambdak =
      x = xk;
      y = yk;
      xk = x + lambda * difx(x, y, h);
      yk = y + lambda * dify(x, y, h);
   } while (abs(getY(x, y) - getY(xk, yk)) > EPS && abs(x - xk) > EPSX && abs(y - yk) > EPSY);
   *x0 = x;
   *y0 = y;
   cout << i << "\n";
}


void DFP()
{

}

int main()
{
   double x, y, x0, y0;

   cin >> x >> y;
   x0 = x;
   y0 = y;
   //Gauss(&x, &y, 0.001);
   Gaussmax(&x, &y, 0.001);
   cout << x << " " << y << "\n";
   //fastdown(&x0, &y0, 0.001, 0.001);
   fastdownmax(&x0, &y0, 0.001, 0.001);
   cout << x0 << " " << y0 << "\n";



}