Problem: As I was cleaning up the warehouse, I found an old document that describes how to get to the treasures of my ancestors. The following was written in this ancient document.


1. First, stand 1m east of the well on the outskirts of the town and turn straight toward the well.
2. Turn clockwise 90 degrees, go straight for 1m, and turn straight toward the well.
3. Turn clockwise 90 degrees, go straight for 1m, and turn straight toward the well.
Four.                   〃
Five.                   〃
6::


From the second line onward, exactly the same thing was written. You wanted to find the treasure, but found it awkward. Unlike in the past, the building is in the way, and you can't see the well even if you go straight in the direction of the well, or you can't go straight even if you try to go straight for 1m. In addition, this ancient document has nearly 1000 lines, and it takes a considerable amount of time and physical strength to work according to the ancient document. Fortunately, however, you can take advantage of your computer.

Enter the number of lines n written in the old document and create a program that outputs the location of the treasure. However, n is a positive integer between 2 and 1,000.



input

Given multiple datasets. For each dataset, one integer n, which represents the number of lines in the old document, is given on each line.

The input ends with -1. The number of datasets does not exceed 50.

output

Assuming that there is a treasure at the position x (m) to the east and y (m) to the north from the well on the outskirts of the town, output each data set in the following format.


x
y


The output is a real number and may contain an error of 0.01 or less.

Example

Input

3
6
-1


Output

0.29
1.71
-2.31
0.80

Solution (in CPP):

Solution:
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <iomanip>

#define EPS 1e-10
#define PI 3.14159265358979
#define DEG_TO_RAD(x) (x * PI / 180.0)
#define RAD_TO_DEG(x) (x * 180.0 / PI)

struct POINT_DOUBLE {
  double x;
  double y;

  POINT_DOUBLE(double x, double y) : x(x), y(y) {}

  bool operator == (const POINT_DOUBLE& other) const {
    return (std::abs(x - other.x) < EPS) && (std::abs(y - other.y) < EPS);
  }

  bool operator < (const POINT_DOUBLE& other) const {
    return x < other.x || (x == other.x && y < other.y);
  }

  void move(double len, double angle) {
    x += len * std::cos(angle);
    y += len * std::sin(angle);
  }
};

int main(void)
{
  int n;
  
  std::cout << std::fixed << std::setprecision(2);

  while (std::cin >> n && n != -1) {
    POINT_DOUBLE pt(1.0, 0.0);
    double angle = DEG_TO_RAD(90);
    for (int i = 0; i < n - 1; i++) {
      pt.move(1.0, angle);
      angle = std::atan2(pt.y, pt.x) + DEG_TO_RAD(90);
    }
    std::cout << pt.x << std::endl;
    std::cout << pt.y << std::endl;
  }

  return 0;
}