#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <functional>
#include <iterator>
#include <iomanip>
#include <cmath>
#include <cassert>
using namespace std;

enum MODE{ARRIVED,STARTED,BURNT};
struct EVENT{
    double time;
    int version;
    MODE mode;
    int option;
    EVENT(){}
    EVENT(double time, int version, MODE mode, int option)
         :time(time),version(version),mode(mode),option(option){}
};
bool operator>(const EVENT&lhs, const EVENT&rhs){
    return lhs.time>rhs.time;
}
typedef priority_queue<EVENT,vector<EVENT>,greater<EVENT> > EVENT_Q;

enum STATE{MOVE,STAY,DONE};
struct Elevator{
    STATE state;
    double height;
    int ev_version;
    double time_to_leave;
    int load;
    
    int capacity;
    double speed;
    int stay_time;
};

const double EPS = 1.0e-8;
#define EQ(x,y) (fabs((x)-(y))<EPS)
#define LT(x,y) ((x)-(y)<-EPS)
int main(void)
{
    int height, nelevator;
    cout.setf(ios::fixed);
    cout<<setprecision(6);
    while ( cin>>height>>nelevator && height>0 ) {
        int distance;
        cin>>distance;
        vector<int> data(height+1,0);
        for ( int i=1 ; i<=height ; ++i )
            cin>>data[i];
        vector<Elevator> lift(nelevator);
        for ( int i=0 ; i<nelevator ; ++i ) {
            Elevator &cur=lift[i];
            cin>>cur.capacity>>cur.speed>>cur.stay_time>>cur.height;
            cur.speed/=distance;
            cur.load=0;
            cur.state = MOVE;
            cur.ev_version = 0;
        }

        EVENT_Q eq;
        {
            int src,t_burn,t_up,t_down;
            cin>>src>>t_burn>>t_up>>t_down;
            for ( int i=2 ; i<=height ; ++i ) {
                int lim = t_burn + (i<src?t_down*(src-i)
                                         :t_up*(i-src));
                eq.push(EVENT(lim,0,BURNT,i));
            }
            eq.push(EVENT(0,0,BURNT,1));
        }
        int saved_data=data[1];
        double last_arrival = 0.0;
        double prev_time = 0.0;
        while (!eq.empty()) {
            EVENT cur_event = eq.top();
            eq.pop();
            //cout<<"@"<<__LINE__<<" mode="<<cur_event.mode<<" op"<<cur_event.option<<endl;
            if ( cur_event.mode!=BURNT &&
                 cur_event.version<lift[cur_event.option].ev_version )
                continue;
            double cur_time = cur_event.time;
            //cout<<"@"<<__LINE__<<endl;
            /*
            cout<<"time="<<prev_time<<"->"<<cur_time<<" mode="<<cur_event.mode
                <<" op="<<cur_event.option
                    <<" saved="<<saved_data<<" la="<<last_arrival<<endl;
            copy(data.begin(), data.end(), ostream_iterator<int>(cout,","));
            cout<<endl;
            for ( int i=0 ; i<nelevator ; ++i )
                cout<<"Sh"<<i<<" h="<<lift[i].height<<" lo="<<lift[i].load<<
                    " st="<<lift[i].state<<endl;
            */
            for ( int i=0 ; i<nelevator ; ++i ) {
                Elevator &cur_lift = lift[i];
                if ( cur_lift.state==MOVE ) {
                    if ( cur_lift.load<cur_lift.capacity &&
                         LT(cur_lift.height,(double)data.size()-1.0) )
                        cur_lift.height += cur_lift.speed*(cur_time-prev_time);
                    else
                        cur_lift.height -= cur_lift.speed*(cur_time-prev_time);
                }
            }
            /*
            for ( int i=0 ; i<nelevator ; ++i )
                cout<<"Sh"<<i<<" h="<<lift[i].height<<" lo="<<lift[i].load<<
                    " st="<<lift[i].state<<endl;
            *///cout<<"@"<<__LINE__<<endl;
            if ( cur_event.mode==BURNT ) {
                if ( cur_event.option<data.size() )
                    data[cur_event.option]=0;
            }
            else if ( cur_event.mode==STARTED )
                lift[cur_event.option].state = MOVE;
            else {}//if ( cur_event.mode==ARRIVED )
            for (int i=0 ; i<nelevator ; ++i ) {
                Elevator &cur_lift = lift[i];
                if ( cur_lift.state==MOVE && EQ(cur_lift.height,1)&&
                     (cur_lift.load==cur_lift.capacity||data.size()<3) ) {
                    if ( cur_lift.load==0 ) {
                        cur_lift.state=DONE;
                        continue;
                    }
                    saved_data += cur_lift.load;
                    last_arrival = max(last_arrival,cur_time+cur_lift.stay_time);
                    cur_lift.load=0;
                    cur_lift.state = STAY;
                    cur_lift.time_to_leave = cur_time + cur_lift.stay_time;
                    eq.push(EVENT(cur_lift.time_to_leave,++cur_lift.ev_version,
                                  STARTED,i));
                }
            }
            //cout<<"@"<<__LINE__<<endl;
            
            do{
                while ( !data.empty() && data.back()==0 )
                    data.pop_back();
                if ( data.empty() )
                    break;
                for ( int i=0 ; i<nelevator ; ++i ) {
                    Elevator &cur=lift[i];
                    if ( cur.state==MOVE && cur.load<cur.capacity &&
                         EQ(cur.height,data.size()-1.0) ) {
                        cur.state=STAY;
                        int toload = min(cur.capacity-cur.load, data.back());
                        cur.load += toload;
                        cur.time_to_leave = cur_time+cur.stay_time;
                        eq.push(EVENT(cur.time_to_leave,++cur.ev_version,
                                      STARTED,i));
                        data.back()-=toload;
                        if ( data.back()==0 )
                            break;
                    }
                }
            }while(!data.empty()&&data.back()==0);
            //cout<<"@"<<__LINE__<<endl;
            for ( int i=0 ; i<nelevator ; ++i ) {
                Elevator &cur=lift[i];
                if ( cur.state==MOVE ) {
                    if ( cur.load==0 && data.empty() )
                        cur.state=DONE;
                    else{
                        int target=1;
                        if ( cur.load<cur.capacity && data.size()>=3 )
                            target = (int)data.size()-1;
                        double diff=fabs(cur.height-target);
                        assert(!EQ(diff,0));
                        eq.push(EVENT(cur_time+diff/cur.speed,++cur.ev_version,
                                      ARRIVED,i));
                    }
                }
            }
            prev_time = cur_time;
            //cout<<"@"<<__LINE__<<endl;
        }
        cout<<saved_data<<" "<<last_arrival<<endl;
    }
    return 0;
}