#include <bits/stdc++.h>

using namespace std;

const int kMaxN = 1e5, kNumIter = 100;
const double kEps = 1e-6;

double a[kMaxN];

double t[2 * kMaxN][kNumIter];
double delta[2 * kMaxN];

double aux[kNumIter];

void Init(int n) {
    for (int i = 0; i < n; ++i) {
        t[i + n][0] = a[i];
        delta[i + n] = 1.0;
        for (int j = 1; j < kNumIter; ++j) {
            t[i + n][j] = t[i + n][j - 1] * a[i];
        }
    }

    for (int i = n - 1; i > 0; --i) {
        delta[i] = 1.0;
        for (int j = 0; j < kNumIter; ++j) {
            t[i][j] = t[i + i][j] + t[i + i + 1][j];
        }
    }
}

void PushLazy(int n) {
    if (fabs(delta[n] - 1.0) < kEps) {
        return;
    }

    double v = delta[n];
    for (int i = 0; i < kNumIter; ++i) {
        t[n][i] *= v;
        v *= delta[n];
    }  
    delta[n + n + 0] *= delta[n];
    delta[n + n + 1] *= delta[n];
    delta[n] = 1.0;
}

void Propagate(int node) {
    for (int d = __lg(node) - 1; d >= 0; --d) {
        PushLazy(node >> (d + 1));
    }
}

void Update(int l, int r, double p) {
    Propagate(l); Propagate(r);
    {
        int l_copy = l, r_copy = r;
        for (; l <= r; l = (l + 1) >> 1, r = (r - 1) >> 1) {
            if (l & 1) {
                delta[l] *= p;
            }
    
            if (~r & 1) {
                delta[r] *= p;
            }
        }
        l = l_copy; r = r_copy;
    }

    for (const int update : {l, r}) {
        for (int i = update; i > 1; i >>= 1) {
            double v0 = delta[i], v1 = delta[i ^ 1];
            for (int j = 0; j < kNumIter; ++j) {
                t[i >> 1][j] = t[i][j] * v0 + t[i ^ 1][j] * v1;
                v0 *= delta[i]; v1 *= delta[i ^ 1];
            }
        }
    }
}

void AddSolution(int node) {
    double v = delta[node];
    for (int i = 0; i < kNumIter; ++i) {
        aux[i] += t[node][i] * v;
        v *= delta[node];
    }
}

void Query(int l, int r) {
    Propagate(l); Propagate(r);
    for (; l <= r; l = (l + 1) >> 1, r = (r - 1) >> 1) {
        if (l & 1) {
            AddSolution(l);
        }
        if (~r & 1) {
            AddSolution(r);
        }
    }
}

int main() {
    cin.tie(0);
    ios_base::sync_with_stdio(false);
    cout.precision(8);
    cout.setf(ios::fixed, ios::floatfield);
    
    int n, q; cin >> n >> q;
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

    Init(n);

    while (q--> 0) {
        int op, l, r; cin >> op >> l >> r;
        --l; --r;
        if (op == 0) {
            for (int i = 0; i < kNumIter; ++i) {
                aux[i] = .0;
            }
            
            Query(l + n, r + n);

            double answer = .0;
            for (int i = 0; i < kNumIter; ++i) {
                answer -= aux[i] / (i + 1);
            }
            cout << exp(answer) << '\n';
        } else {
            double p; cin >> p;
            Update(l + n, r + n, p);
        }
    }

    return 0;
}