import java.util.ArrayList;

public class simulator {

    private double clock,T;
    private ArrayList<Server> servers;
    private ArrayList<Message> messageQueue;
    private EventGenerator eventGenerator;
    private int serverDrops;
    private double totalHandlingTime;
    private int M;
    simulator(double lambda,double miu,double alpha,double beta,int k,double T)
    {
        this.T = T;
        clock = 0;
        serverDrops = 0;
        totalHandlingTime = 0;
        M = 0;
        Message.DISTRIBUTION = lambda;
        ServerDrop.DISTRIBUTION = alpha;
        ServerRepair.DISTRIBUTION = beta;
        messageQueue = new ArrayList<Message>();
        eventGenerator = new EventGenerator();
        servers = new ArrayList<Server>(k);
        for (int i = 0 ; i < k ; ++i)
        {
            servers.add(new Server(miu));
        }
    }

    private int countMessages()
    {
        int count = messageQueue.size();
        for (Server s : servers)
        {
            if (!s.isFree())
                ++count;
        }
        return count;
    }
    private Server getMinimalFreeServer()
    {
        Server minServer = null;
        for (Server server : servers)
        {
            if (server.isActive && server.isFree())
            {
                if (minServer == null)
                {
                    minServer = server;
                }
                else
                {
                    if (server.operationEnd < minServer.operationEnd)
                    {
                        minServer = server;
                    }
                }
            }
        }
        return minServer;
    }

    private Server getMinimalServer()
    {
        Server minServer = servers.get(0);
        for (Server server : servers)
        {
            if (server.isActive && server.operationEnd < minServer.operationEnd)
                minServer = server;
        }
        return minServer;
    }
    private void DisableServer()
    {
        for (Server s : servers)
        {
            if (s.isActive == true)
            {
                s.isActive = false;
                if (!s.isFree()) {
                    messageQueue.add(s.disable(clock));
                }
                break;
            }
        }
        ++serverDrops;
    }

    private void EnableServer()
    {
        for (Server s : servers)
        {
            if (s.isActive == false)
            {
                s.isActive = true;
                if (!messageQueue.isEmpty())
                    s.addMessage(messageQueue.remove(0),clock);
                break;
            }
        }
    }
    private void updateServers()
    {
        int currentMessages = countMessages();
        if (currentMessages > M)
            M = currentMessages;
        for (Server s : servers)
        {
            s.update(clock);
        }
    }
    private void updateSimulator()
    {
        updateServers();
        while (!messageQueue.isEmpty())
        {
            Server openServer = getMinimalFreeServer();
            if (openServer == null)
            {
                break;
            }
            Message message = messageQueue.remove(0);
            openServer.addMessage(message, Math.max(openServer.operationEnd,message.getArrival()));
            openServer.update(clock);
        }
    }
    private void emptyQueue()
    {
        while (!messageQueue.isEmpty())
        {
            clock = getMinimalServer().operationEnd;
            updateSimulator();
        }
    }
    public void Simulate()
    {
        int N = 0;
        while ( clock < T || !messageQueue.isEmpty() )
        {
            if (clock >= T)
            {
                eventGenerator.StopGeneratingMessages();
            }
            Event event = eventGenerator.getEvent();
            if (event == null)
            {
                emptyQueue();
                break;
            }
            clock = event.getArrival();
            if (event instanceof Message)
            {
                messageQueue.add((Message)event);
            }
            else if (event instanceof ServerDrop)
            {
                DisableServer();
            }
            else {
                EnableServer();
            }
            updateSimulator();
        }
        for (Server s : servers)
        {
            N+=s.messagesHandled;
            totalHandlingTime += s.totalHandlingTime;
        }
        System.out.println(N + " " + serverDrops + " " + totalHandlingTime/clock
                           + " " + clock + " " + totalHandlingTime/N + " " + M);
    }
    public static void main(String args[])
    {
        new simulator(50,63,0,1,1,10000).Simulate();
    }
}

import java.util.Random;


public class Exponential {
    public static double Instance(double miu)
    {
        return -Math.log(new Random().nextDouble())/miu;
    }
}


class Server {
    public Message activeMessage;
    public double miu;
    public double operationStart,operationEnd;
    public double totalHandlingTime;
    public boolean isActive;
    public int messagesHandled;
    Server(double miu) {
        activeMessage = null;
        operationStart = 0;
        operationEnd = 0;
        messagesHandled = 0;
        totalHandlingTime = 0;
        this.miu = miu;
        isActive = true;
    }
    public boolean isFree() { return (activeMessage == null); }
    public void update(double clock) {
        if ( clock >= operationEnd && activeMessage != null)
        {
            ++messagesHandled;
            totalHandlingTime += operationEnd - activeMessage.getArrival();
            activeMessage = null;
        }
    }
    public Message disable(double clock)
    {
        Message message = (activeMessage == null) ? null :  new Message(activeMessage);
        if (activeMessage != null)
            totalHandlingTime += clock - operationStart;
        activeMessage = null;
        isActive = false;
        return message;
    }
    public void addMessage(Message message,double time)
    {
        if (message == null)
        {
            return;
        }
        activeMessage = message;
        operationStart = time;
        operationEnd = operationStart + Exponential.Instance(miu);
    }
}

class EventGenerator {
    private Message message;
    private ServerDrop serverDrop;
    private ServerRepair serverRepair;
    private boolean generateMessages;
    private boolean generateRepairs;
    private boolean generateDrops;
    public void StopGeneratingMessages() {
        generateMessages = false;
    }
    public EventGenerator()
    {
        message = new Message(Exponential.Instance(Message.DISTRIBUTION));
        serverDrop = new ServerDrop(Exponential.Instance(ServerDrop.DISTRIBUTION));
        serverRepair = new ServerRepair(Exponential.Instance(ServerRepair.DISTRIBUTION));
        generateMessages = (Message.DISTRIBUTION != 0);
        generateRepairs = (ServerRepair.DISTRIBUTION != 0);
        generateDrops = (ServerDrop.DISTRIBUTION != 0);
    }

    public Event getEvent() {
        Event result;
        if ( (generateMessages == true) &&
           ( (message.getArrival() <= serverDrop.getArrival()) || (generateDrops == false) ) &&
           ( (message.getArrival() <= serverRepair.getArrival()) || (generateRepairs == false) ))
        {
            double exponentialInstance = Exponential.Instance(Message.DISTRIBUTION);
            result = new Message(message.getArrival());
            message = new Message(message.getArrival()+exponentialInstance);
        }
        else if ( (generateDrops == true) &&
                ( (serverDrop.getArrival() <= serverRepair.getArrival()) || (generateRepairs == false) ) )
        {
            double exponentialInstance = Exponential.Instance(ServerDrop.DISTRIBUTION);
            result = new ServerDrop(serverDrop);
            serverDrop = new ServerDrop(serverDrop.getArrival()+exponentialInstance);
        }
        else if (generateRepairs == true)
        {
            double exponentialInstance = Exponential.Instance(ServerRepair.DISTRIBUTION);
            result = new ServerRepair(serverRepair);
            serverRepair = new ServerRepair(serverRepair.getArrival()+exponentialInstance);
        }
        else
        {
            result = null;
        }
        return result;
    }
}

class Event {
    public double getArrival() { return arrival; }
    public void setArrival(double arrival) { this.arrival = arrival; }
    public Event(double start) { this.arrival = start; }
    public Event(Event e) {
        this.arrival = e.arrival;
    }
    private double arrival;
}

class Message extends Event {
    public static double DISTRIBUTION;
    public Message(double start) {
        super(start);
    }
    public Message(Message message) {
        super(message);
    }

}

class ServerDrop extends Event {
    public static double DISTRIBUTION;
    public ServerDrop(double start) {
        super(start);
    }
    public ServerDrop(ServerDrop serverDrop) {
        super(serverDrop);
    }
}

class ServerRepair extends Event {
    public static double DISTRIBUTION;
    public ServerRepair(double start) {
        super(start);
    }
    public ServerRepair(ServerRepair serverRepair) {
        super(serverRepair);
    }
}