func_code_string: #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;   }   