#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using uint8 = unsigned char;
using uint16 = unsigned short int;
using uint32 = unsigned int;
using uint64 = unsigned long long;
using int8 = signed char;
using int16 = short int;
using int32 = int;
using int64 = long long;
using dr = double;
using pi32 = std::pair<int32, int32>;
using pi64 = std::pair<int64, int64>;
using pi64i32 = std::pair<int64, int32>;
using pi32pi32 = std::pair<int32, pi32>;
using cpdr = std::complex<dr>;
using vi32 = std::vector<int32>;
using qi32 = std::queue<int32>;
using spi32 = std::set<pi32>;
using spi32it = spi32::iterator;
namespace oct {
const int tn4[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
const int tn8[8][2] = {{1, 0},  {1, 1},   {0, 1},  {-1, 1},
                       {-1, 0}, {-1, -1}, {0, -1}, {1, -1}};
const dr exp = 1e-8;
void sync(int pre = 8);
template <typename _Tp>
_Tp &mad(_Tp &x, _Tp y);
template <typename _Tp>
_Tp &mid(_Tp &x, _Tp y);
template <typename _Tp>
bool in(_Tp x, _Tp l, _Tp r);
template <typename _Tp>
_Tp sqr(_Tp x);
template <typename _Tp>
_Tp power(_Tp x, int64 m);
template <typename _Tp>
void sort(_Tp &x, _Tp &y);
template <typename _Tp1, typename _Tp2>
std::pair<_Tp1, _Tp2> operator+(std::pair<_Tp1, _Tp2> x,
                                std::pair<_Tp1, _Tp2> y);
template <typename _Tp>
_Tp &operator+=(_Tp &x, _Tp y);
inline void sync(int pre) {
  std::ios::sync_with_stdio(0);
  std::cin.tie(0), std::cout.tie(0);
  std::cout.flags(std::ios::fixed);
  std::cout.precision(pre);
  std::cout.setf(std::ios::showpoint);
}
template <typename _Tp>
inline _Tp &mad(_Tp &x, _Tp y) {
  return x = std::max(x, y);
}
template <typename _Tp>
inline _Tp &mid(_Tp &x, _Tp y) {
  return x = std::min(x, y);
}
template <typename _Tp>
inline bool in(_Tp x, _Tp l, _Tp r) {
  return l <= x && x <= r;
}
template <typename _Tp>
inline _Tp sqr(_Tp x) {
  return x * x;
}
template <typename _Tp>
inline _Tp power(_Tp x, int64 m) {
  return m == 1 ? x : (m & 1 ? power(x * x, m / 2) * x : power(x * x, m / 2));
}
template <typename _Tp>
inline void sort(_Tp &x, _Tp &y) {
  if (x > y) std::swap(x, y);
}
template <typename _Tp1, typename _Tp2>
inline std::pair<_Tp1, _Tp2> operator+(std::pair<_Tp1, _Tp2> x,
                                       std::pair<_Tp1, _Tp2> y) {
  return x.first += y.first, x.second += y.second, x;
}
template <typename _Tp>
_Tp &operator+=(_Tp &x, _Tp y) {
  return x = x + y;
}
}  // namespace oct
const int N = 100005;
dr ta, tb, tc;
dr a[N], b[N], s[N], t[N];
int n;
int main() {
  oct::sync();
  std::cin >> n;
  for (int i = 1; i <= n; ++i) std::cin >> a[i], a[i] += a[i - 1];
  for (int i = 1; i <= n; ++i) std::cin >> b[i], b[i] += b[i - 1];
  for (int i = 1; i <= n; ++i) {
    ta = 1, tb = -(a[i] + b[i]), tc = a[i];
    s[i] = (-tb - sqrt(std::abs(tb * tb - 4 * ta * tc))) / (2 * ta);
    t[i] = (-tb + sqrt(std::abs(tb * tb - 4 * ta * tc))) / (2 * ta);
  }
  for (int i = 1; i <= n; ++i) std::cout << s[i] - s[i - 1] << ' ';
  std::cout << std::endl;
  for (int i = 1; i <= n; ++i) std::cout << t[i] - t[i - 1] << ' ';
  std::cout << std::endl;
  return 0;
}
