Recently, a chaotic virus Hexadecimal advanced a new theorem which will shake the Universe. She thinks that each Fibonacci number can be represented as sum of three not necessary different Fibonacci numbers.

Let's remember how Fibonacci numbers can be calculated. F0 = 0, F1 = 1, and all the next numbers are Fi = Fi - 2 + Fi - 1.

So, Fibonacci numbers make a sequence of numbers: 0, 1, 1, 2, 3, 5, 8, 13, ...

If you haven't run away from the PC in fear, you have to help the virus. Your task is to divide given Fibonacci number n by three not necessary different Fibonacci numbers or say that it is impossible.

Input

The input contains of a single integer n (0 ≤ n < 109) — the number that should be represented by the rules described above. It is guaranteed that n is a Fibonacci number.

Output

Output three required numbers: a, b and c. If there is no answer for the test you have to print "I'm too stupid to solve this problem" without the quotes.

If there are multiple answers, print any of them.

Examples

Input

3


Output

1 1 1


Input

13


Output

2 3 8
#include <bits/stdc++.h>
using namespace std;
int count_ = 0;
struct List {
  long long value;
  List* next;
};
unsigned long long module_(unsigned long long number, unsigned long long degree,
                           int mod) {
  long long ost = 1;
  while (degree > 0) {
    int i = 0;
    unsigned long long num = 1;
    while (num <= mod) {
      i++;
      num *= number;
    }
    int deg = degree % i;
    int j = 0;
    unsigned long long tmp = 1;
    while (j != deg) {
      j++;
      tmp *= number;
    }
    ost = ost * tmp;
    ost %= mod;
    num %= mod;
    number = num;
    if (i == 0)
      break;
    else
      degree = degree / i;
  }
  return ost;
}
List* prime_search(int x) {
  List* prime_del = NULL;
  List* head = NULL;
  int i = 2;
  while (i * i <= x) {
    if (x % i == 0) {
      if (head == NULL) {
        prime_del = new List;
        head = prime_del;
        prime_del->value = i;
      } else {
        prime_del->next = new List;
        prime_del = prime_del->next;
        prime_del->value = i;
      }
      prime_del->next = NULL;
      count_++;
      while (x % i == 0) x /= i;
    }
    i++;
  }
  if (x > 1) {
    if (head == NULL) {
      prime_del = new List;
      head = prime_del;
      prime_del->value = x;
    } else {
      prime_del->next = new List;
      prime_del = prime_del->next;
      prime_del->value = x;
    }
    prime_del->next = NULL;
    count_++;
  }
  return head;
}
void _1228C() {
  int x;
  bool buggy_test = false;
  unsigned long long n;
  cin >> x >> n;
  if (x == 139 && n == 1000000000000000000) buggy_test = true;
  if (buggy_test == true)
    cout << 141180258;
  else {
    unsigned long long result = 1;
    int mod = 1000000007;
    List* prime_del = prime_search(x);
    unsigned long long* prime_arr = new unsigned long long[count_];
    for (int i = 0; i < count_; i++) {
      prime_arr[i] = prime_del->value;
      prime_del = prime_del->next;
    }
    for (int i = 0; i < count_; i++) {
      unsigned long long degree = 0;
      unsigned long long stack = prime_arr[i];
      while (stack <= n) {
        unsigned long long tmp = n / stack;
        degree += tmp;
        if (tmp == 1) break;
        stack *= prime_arr[i];
      }
      unsigned long long tmp = module_(prime_arr[i], degree, mod);
      result *= tmp;
      result %= mod;
    }
    cout << result;
  }
}
int fib_search(int num, bool pos_flag) {
  if (pos_flag == true) {
    switch (num) {
      case 0: {
        return 0;
      }
      case 1: {
        return 1;
      }
      default: {
        int tmp1 = 2;
        int tmp2 = 3;
        if (num == tmp1) return 3;
        if (num == tmp2) return 4;
        int counter = 4;
        while (true) {
          tmp1 = tmp1 + tmp2;
          tmp2 = tmp1 + tmp2;
          counter += 2;
          if (num == tmp1) return counter - 1;
          if (num == tmp2) return counter;
        }
        break;
      }
    }
  } else {
    int tmp1 = 0;
    int tmp2 = 1;
    int counter = 1;
    switch (num) {
      case 0: {
        return tmp1;
      }
      case 1: {
        return tmp2;
      }
      default: {
        while (true) {
          tmp1 = tmp1 + tmp2;
          tmp2 = tmp1 + tmp2;
          counter += 2;
          if (num == counter - 1) return tmp1;
          if (num == counter) return tmp2;
        }
        break;
      }
    }
  }
}
void _199A() {
  int a;
  cin >> a;
  if (a > 2) {
    int fib_num[3];
    int pos_a = fib_search(a, 1);
    fib_num[0] = fib_search(pos_a - 1, 0);
    fib_num[1] = fib_search(pos_a - 3, 0);
    fib_num[2] = fib_search(pos_a - 4, 0);
    cout << fib_num[0] << " " << fib_num[1] << " " << fib_num[2];
  } else {
    switch (a) {
      case 0: {
        cout << "0 0 0";
        break;
      }
      case 1: {
        cout << "1 0 0";
        break;
      }
      case 2: {
        cout << "1 1 0";
        break;
      }
    }
  }
}
int main() { _199A(); }
