#include <iostream>
using namespace STD

// zbytky z minule (budou se hodit)
void swapC(int*a, int*b) {
  int c=*a;
  *a=*b;
  *b=c;
}

// swap s referencemi (vicemene jen magicka syntaxe pro predchozi definici)
void swap(int &a, int &b) {
  int c=a;
  a=b;
  b=c;
}

// swap pretizeny pro floaty (pri kompilaci se podle typu parametru vybere
// spravna verze)
void swap(float &a, float &b) {
  float c=a;
  a=b;
  b=c;
}

// uplne genericky swap pro libovolny typ (pri kompilaci se z sablony podle
// potreby instancuji verze funkce specializovane pro nejaky typ, napriklad pro
// T=int a T=float.
template<typename T>
void swap(T &a,T &b){
  T c = a;
  a = b;
  b = c;
}

// genericka funkce ktera jen vrati zkopirovany argument
template<typename T>
T id(T x) {
  return x;
}

// bobblesort na integerove arrayi
void bubblesort(int*a, size_t n)
{
  for(size_t i=0;i<n;++i)
    for(size_t j=0; j+1<n; ++j)
      if(a[j]>a[j+1])
        swapC(a+j, a+j+1); // <- pointerova aritmetika, a[b] == *(a+b)
}

// genericky bubblesort
template<typename T>
void bubblesort(T *a, size_t n)
{
  for(size_t i=0;i<n;++i)
    for(size_t j=0; j+1<n; ++j)
      if(a[j]>a[j+1])
        swap(a[j], a[j+1]);
}

// komplexni cislo s generickym "nosnym" typem, tj. muzete vyrobit komplex z
// integeru, z floatu, doublu, apod.
template<typename T>
struct Complex {
  T real;
  T imag;
  Complex(T real,T imag):real(real),imag(imag){}
#if 0
  // dlouha a min efektivni verze toho sameho:
  Complex(T real,T imag) {
    this->real = real;
    this->imag = imag;
  }
#endif

  // defaultni konstruktor, zajisti ze vsechny vyrobene Complexy jsou
  // inicializovane na nulu
  Complex(){
    real = 0;
    imag = 0;
  }

  // operator na nasobeni. Pro vyraz a*b se hledani operatory pretizene jako:
  //  a.operator*(b)
  // nebo podobne globalni jako:
  //  operator*(a,b)
  Complex operator*(Complex other) {
    return Complex(real*other.real - imag*other.imag,
                   real*other.imag + imag*other.real);
  }

  // nasobeni skalarem zprava
  Complex operator* (T b){
    return Complex(real*b, imag*b);
  }

  // unarni minus
  Complex operator- (){
    return Complex(-1*real, -1*imag);
  }

  // inkrementace. Parametr jsem predelal na konstantni referenci -- obcas je
  // dobre vynutit predani referenci a zabranit zbytecnemu kopirovani celeho
  // objektu (napr. kdyby to byl Complex z nejakych long long long doublu.
  Complex& operator+= (const Complex& other)
  {
    // *this = (*this)+other; // kratsi ale trochu min efektivni varianta
    real += other.real;
    imag += other.imag;
    return *this; // tohle dovoluje retezeni operatoru,  `a += b += 3` apod.
    // podobne je zarizene zretezene prirazeni, `a=b=c=Complex(0,0)`.
    // Pozn. operator= jde taky pretizit, ale C++ pro struktury vyrabi
    // "defaultni" ktery nam tady staci.
  }
};

// nasobeni skalarem zleva (prevede se na predchozi pripad)
template<typename T>
inline Complex<T> operator*(T b, Complex<T> a){
  return a*b;
}

// scitani (ekvivalentne by slo definovat uvnitr tridy, s nejakou mirnou
// syntaktickou usporou)
template<typename T>
Complex<T> operator+ (Complex<T> a, Complex<T> b) { 
  return Complex<T>(a.real + b.real, a.imag + b.imag);
#if 0
  // ekvivalent:
  Complex result;
  
  result.real = a.real + b.real;
  result.imag = a.imag + b.imag;

  return result;
#endif
}

// operator >> pretizeny tak, aby dovolil ze vstupu nacist komplexni cislo
template<typename T>
istream& operator>>(istream &i, Complex<T>& number) {
  i >> number.real >> number.imag;
  return i;

}

// tosame pro operator <<
template<typename T>
ostream& operator<<(ostream &i, const Complex<T>& number) {
  i << number.real << ' ' << number.imag;
  return i;

}

int main() {
  
  Complex<float> a,b;
  // puvodni verze: cin >> a.real >> a.imag >> b.real >> b.imag;
  cin >> a >> b;
  Complex<float> result = -a*b+a;
  cout << result*10 << std::endl;
  result += Complex(10,0);
  cout << (a+b+result) << endl;
  
#if 0
  // puvodni kod s generickym bubblesortem
  double arr[5];
  for(size_t i = 0; i < 5; i++)
    std::cin >> arr[i];
  
  bubblesort(arr, 5);
  for(size_t i = 0; i < 5; i++)
    std::cout << arr[i] << std::endl;
#endif
  return 0;
}