#pragma comment(linker, "/stack:2048000000")

#define _crt_secure_no_deprecate
#define _crt_secure_no_warnings
#define _use_math_defines
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <string.h>
#include <assert.h>
#include <memory.h>
#include <fstream>
#include <iostream>
#include <iomanip>
#include <string>
#include <sstream>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <utility>
#include <algorithm>
#include <random>
#include <bitset>
#include <unordered_set>
#include <unordered_map>
#include <complex>
#include <tuple>

using namespace std;

typedef long long int64;
typedef unsigned long long uint64;
typedef pair<int, int> pii;
typedef pair<int64, int64> pll;
typedef pair<int64, int> pli;
typedef pair<int, int64> pil;
typedef pair<int, bool> pib;
const int inf = (int) (1e9 + 1e5);
const int64 linf = (int64) (2e18);
const int64 base = 1003;
const double eps = 1e-9;
#define sq(x) ((x)*(x))
#define fail(what) {throw logic_error(string(what));}
#define ASSERT(exp) {if (!(exp)) {fail("");}}
#define ASSERTC(exp, what) {if (!(exp)) {fail(what);}}
#define y1 fjgjf
//typedef complex<double> comp;
const int mod = 998244353;//1'000'000'007;

int add(int a, int b) {
    a += b;
    if (a >= mod) {
        a -= mod;
    }
    return a;
}

int sub(int a, int b) {
    a -= b;
    if (a < 0) {
        a += mod;
    }
    return a;
}

int mul(int a, int b) {
    return int64(a) * b % mod;
}

int bin_pow(int a, int b) {
    int res = 1;
    while (b) {
        if (b & 1) {
            res = mul(res, a);
        }
        b >>= 1;
        a = mul(a, a);
    }
    return res;
}

int back(int a) {
    return bin_pow(a, mod - 2);
}

int divv(int a, int b) {
    return mul(a, back(b));
}

int tnum;

int n, m;
vector<double> x, y;
vector<double> px, py, pxx, pxy;
int ans;

void init() {
    cin >> n;
    x.resize(n);
    y.resize(n);
    for (int i = 0; i < n; ++i) {
        cin >> x[i] >> y[i];
    }
}

inline double get(const vector<double>& p, int l, int r) {
    auto res = p[r];
    if (l > 0) {
        res -= p[l - 1];
    }
    return res;
}

void solve() {
    px.resize(n);
    py.resize(n);
    pxx.resize(n);
    pxy.resize(n);
    for (int i = 0; i < n; ++i) {
        px[i] = x[i] + (i > 0 ? px[i - 1] : 0);
        py[i] = y[i] + (i > 0 ? py[i - 1] : 0);
        pxx[i] = x[i] * x[i] + (i > 0 ? pxx[i - 1] : 0);
        pxy[i] = x[i] * y[i] + (i > 0 ? pxy[i - 1] : 0);
    }

    cin >> m;
    for (int i = 0; i < m; ++i) {
        int l, r;
        double lamb, x;
        cin >> l >> r >> lamb >> x;
        --l;
        --r;

        const double sx = get(px, l, r);
        const double sy = get(py, l, r);
        const double sxy = get(pxy, l, r);
        const double sxx = get(pxx, l, r);
        const double cnt = (r - l + 1);
        const double k = ((cnt + lamb) * sxy - sx * sy) / ((cnt + lamb) * (sxx + lamb) - sx * sx);
        const double b = (sy - k * sx) / (cnt + lamb);

        cout << std::fixed << std::setprecision(8) << (k * x + b) << "\n";
    }
}

void print_answer() {
}

void precalc() {
}

void run() {
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin);
    freopen("output.txt", "wt", stdout);
#endif
    precalc();
    int t = 1;
    //cin >> t;
    //scanf ("%d", &t);
    for (tnum = 1; tnum <= t; ++tnum) {
        init();
        solve();
        print_answer();
    }
}

signed main() {
    srand(94);
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    run();
    return 0;
}