#include <string>
#include <iostream>
#include <fstream>
#include <vector>

#ifdef D
#define _V(_v) cout << "Var: " #_v ": " << _v << " Line: " << __LINE__ << endl;
#else
#define _V(_v)
#endif

int main (int c, char **v)
{
    ifstream in ("centauri.in");
    
    int nr = 0, ports, robs;
    
    while ((in >> ports >> robs), (ports != 0 || robs != 0))
    {
        int *robcap = new int [robs];
        int *robact = new int [robs];
        int *robst  = new int [robs];
        int *robtar = new int [robs];
        int *robpos = new int [robs];
        int *robload= new int [robs];
        
        for (int i = 0; i < robs; i++)
        {
            in >> robcap[i];
            robact[i] = 0;
            robpos[i] = 0;
        }
        
        vector <int> reqcap;
        vector <int> reqst;
        vector <int> reqtar;
        vector <int> reqtim;
        
        int cap, st, tar, tim;
        
        while ((in >> tim >> st >> tar >> cap), (tim + 1 || st + 1 || tar + 1 || cap + 1))
        {
            reqcap.push_back (cap);
            reqst.push_back  (st);
            reqtar.push_back (tar);
            reqtim.push_back (tim);
        }
        
        int reqs = reqcap.size (), time = 0, busy = 0, wrk = 0, busysum = 0;
        
        while (reqtim.size() || busy)
        {time++;
            // assign robots
            int ass = 0;
            do 
            {
                for (unsigned int i = 0; i < reqcap.size(); i++)
                {
                    if (reqtim[i] <= time)
                    {
                        int rob, delta = ports;
                        for (int j = 0; j < robs; j++)
                        {
                            if (!robact[j] && robcap[j] >= reqcap[i])
                            {
                                int newdelta = (ports - robpos[j] + reqst[i]) % ports;
                                if (delta > newdelta || (delta == newdelta &&
                                robcap[rob] > robcap[j]))
                                {
                                    delta = newdelta;
                                    rob = j;
                                }
                            }
                        }
                        if (delta < ports)
                        {
                            robload[rob] = 5;
                            robact [rob] = 1;
                            robst  [rob] = reqst[i];
                            robtar [rob] = reqtar[i];
                            ass = 1;
                            busy++;
                            reqcap.erase (reqcap.begin () + i);
                            reqst .erase (reqst.begin () + i);
                            reqtim.erase (reqtim.begin () + i);
                            reqtar.erase (reqtar.begin () + i);
                            break;
                        }
                    }
                }
            } while (ass);
            // move robots
            busysum += busy;
            for (int i=0; i<robs; i++)
            {
                if (robact[i])
                {
                    wrk++;
                    switch (robact[i]) 
                    {
                        case 1:
                            if (robpos[i] != robst[i])
                            {
                                (robpos[i] += 1) %= ports;
                                break;
                            }
                            if (robload[i])
                            {
                                robload[i]--;
                                break;
                            }
                            robload[i] = 5;
                            robact[i] = 2;
                        case 2:
                            if (robpos[i] != robtar[i])
                            {
                                (robpos[i] += 1) %= ports;
                                break;
                            }
                            if (robload[i])
                            {
                                robload[i]--;
                                break;
                            }
                            robact[i] = 0;
                            busy--;
                            wrk--;
                    }
                }
            }
        }
        
        // output results
        cout << "Simulation " << ++nr << endl;
        cout << "Average wait time   = " << wrk / reqs << "." << ((wrk % reqs) *
        1000) / reqs << " minutes" << endl;
        cout << "Average utilisation = " << busysum / time << "." << ((busysum %
        time) * 1000) / time << " %" << endl << endl;
    }
    
}