#include<bits/stdc++.h>

using namespace std;

typedef long double ll;

const int MX = (1<<20);

bool debug = 1;

struct DATA{

    int toLeft , toRight;

    int cnt;

    ll H;

};

DATA data[MX];

int par[MX];

int n , QN;

int find_(int x){
    if(x == par[x]) return x;
    return par[x] = find_(par[x]);
}

ll EPS = 1e-10;


int L[MX] , R[MX];

int findLeft(int x){
    if(x == L[x]) return x;
    return L[x] = findLeft(L[x]);
}

int findRight(int x){
    if(x == R[x]) return x;
    return R[x] = findRight(R[x]);
}


int linkLeft(int x , int y){

    x = findLeft(x) , y = findLeft(y);
    if(x > y) swap(x , y);
    if(x != y) L[y] = x;

}
int linkRight(int x , int y){
    x = findRight(x) , y = findRight(y);
    if(x > y) swap(x , y);
    if(x != y) R[x] = y;
}




void merge_(int x , int y){

    if(x == 0 || y == 1 + n) return;

    x = find_(x) , y = find_(y);

    if(x == y) return;

    if(abs(data[x].H - data[y].H) > EPS) return;

    if(x > y)
        swap(x , y);

    par[y] = x;

    data[x].cnt += data[y].cnt;

    data[x].toRight = max(data[x].toRight , data[y].toRight);

    data[x].toLeft = min(data[x].toLeft , data[y].toLeft);

    linkLeft(x , y);

    linkRight(x , y);

    //data[x].lessToLeft = min(data[x].lessToLeft , data[y].lessToLeft);

    //data[x].lessToRight = max(data[x].lessToRight , data[y].lessToRight);
}

ll inf;



void add(int pos , ll V){
    if(debug){cout<<"#"<<"addedto"<<' '<<pos<<' '<<V<<endl;}

    pos = find_(pos);

    V /= data[pos].cnt;

    data[pos].H += V;

    data[pos].H = min(data[pos].H , inf);

    merge_(data[pos].toLeft , data[pos].toLeft - 1);
    merge_(data[pos].toRight , data[pos].toRight + 1);

    pos = find_(pos);

    int rightmost = data[pos].toRight;

    if(rightmost != n)
        if(data[pos].H >= data[find_(rightmost + 1)].H)
            linkRight(rightmost , rightmost + 1);
                //      data[pos].lessToRight = data[find_(pos + 1)].lessToRight;
    int leftmost = data[pos].toLeft;

    if(leftmost != 1)
        if(data[pos].H >= data[find_(leftmost - 1)].H)
            linkLeft(leftmost , leftmost - 1);
        //    data[pos].lessToLeft = data[find_(pos - 1)].lessToLeft;*/
}



ll find_dif(int pos){
    //cout<<pos<<endl;

    int leftside = data[find_(pos)].toLeft , rightside = data[find_(pos)].toRight;

    ll rightdif =  + data[find_(rightside + 1)].H - data[find_(pos)].H;

    ll leftdif =   + data[find_(leftside - 1)].H - data[find_(pos)].H;

    rightdif = max(rightdif , (ll) (0.0));

    leftdif = max(leftdif ,ll(0.0));
    //cout<<pos<<' '<<rightdif<<' '<<leftdif<<endl;

    rightdif *= data[find_(pos)].cnt;

    leftdif *= data[find_(pos)].cnt;

    if(leftside == 1)
        return rightdif;
    if(rightside == n)
        return leftdif;
    return min(rightdif , leftdif);
}


void pour(int pos , ll V){
    if(debug){
        cout<<"POUR "<<pos<<' '<<V<<endl;
    }

    if(V < EPS) return;


    int head = find_(pos);

    int lessToLeft = findLeft(pos);
    int lessToRight = findRight(pos);

    ll a = find_dif(lessToLeft);

    ll b = find_dif(lessToRight);



    int leftmost = data[head].toLeft;
    int rightmost = data[head].toRight;

    if(lessToLeft == leftmost) a = 0.0;
    if(lessToRight == rightmost) b = 0.0;

    //cout<<pos<<' '<<a<<' '<<b<<' '<<data[head].toLeft<<' '<<data[head].toRight<<' '<<lessToLeft<<' '<<lessToRight<<endl;

    if(a == 0.0 && b == 0.0){

        ll toadd = min(find_dif(leftmost) , find_dif(rightmost));
        toadd = min(toadd , V);
        if(leftmost == 1 && rightmost == n)
            toadd = V;
        add(pos , toadd);
        pour(pos , V - toadd);
        return;
    }

    if(a == 0.0){
        b = min(b , V);
        add(lessToRight , b);
        pour(pos , V - b);
    }

    else
    if(b == 0.0){
        a = min(a , V);
        add(lessToLeft , a);
        pour(pos , V - a);
    }
    else{
        ll mn = min(a , b);
        if(2.0 * mn <= V){
            add(lessToLeft , mn);
            add(lessToRight , mn);
            pour(pos , V - 2 * mn);
        }
        else{
            add(lessToLeft , V/2.0);
            add(lessToRight , V/2.0);
        }
    }
}

int T , arr[MX];


int main(){
   // freopen("input4.in","r",stdin);
  //  freopen("output4.out","w",stdout);
    debug = 0;
    scanf("%d",&T);
    while(T--){


        scanf("%d %d",&n,&QN);

        for(int j = 1 ; j <= n ; j++){
            scanf("%d",&arr[j]);
        }

        int mx = *max_element(arr+1 , arr+1+n);

        inf = mx;

        for(int j = 1 ; j <= n ; j++){
            arr[j] = mx - arr[j];
            L[j] = R[j] = j;
            par[j] = j;
            if(j > 1 && arr[j - 1] < arr[j]) L[j] = L[j - 1];
        }





        for(int j = n - 1 ; j ; j--){
            if(j != n && arr[j + 1] < arr[j])
                R[j] = R[ j + 1 ];
        }




        for(int j = 1 ; j <= n ; j++){
            data[j].cnt = 1;
            data[j].H = arr[j];
            data[j].toLeft = j;
            data[j].toRight = j;
        }

        if(debug){for(int j = 1 ; j <= n ; j++) cout<<data[find_(j)].H<<' '; puts("");}


        for(int j = 2 ; j <= n ; j++){
            if(arr[j] == arr[j - 1])
                merge_(j , j - 1);
        }
        while(QN--){
            int cmd , index;
            scanf("%d %d",&cmd,&index);
            long long V;
            if(cmd == 1){
                scanf("%lld",&V);
                pour(index , V);
                if(debug){for(int j = 1 ; j <= n ; j++) cout<<data[find_(j)].H<<' '; puts("");}
            }
            else{
                ll ss = mx;
                ss -= data[find_(index)].H;
//                ss = max(ss , (ll) (0.0));
                cout<<fixed<<setprecision(10)<<ss<<endl;
            }

        }
        //cout<<"ok"<<endl;
    }


}