void MLF() {
    int currentTime = 0;
    float avgTime = 0;
    int procsCompleted = 0;
    vector<int> totalTimes( processVect.size() );
    vector<int> runTimes( processVect.size() );
    vector<Process*> processes;
    queue<Process*> priorityQueue[5];
    map<Process*, int> timeMap;

    while(procsCompleted < processVect.size()) {
        processes = getProcesses(currentTime);

        for(int i = 0; i < processes.size(); i++) {
            Process *process = processes.at(i);
            if( timeMap.find(process) == timeMap.end() ) {
                priorityQueue[4].push(process);
                timeMap.emplace(process, 0);
            }
        }

        int queueIndex = -1;
        if(priorityQueue[4].size() > 0) {
            queueIndex = 4;
        }
        else if(priorityQueue[3].size() > 0) {
            queueIndex = 3;
        }
        else if(priorityQueue[2].size() > 0) {
            queueIndex = 2;
        }
        else if(priorityQueue[1].size() > 0) {
            queueIndex = 1;
        }
        else if(priorityQueue[0].size() > 0) {
            queueIndex = 0;
        }

        if(queueIndex == -1) {
            currentTime += 1;
        }
        else {
            Process *process = priorityQueue[queueIndex].front();
            currentTime += 1;
            runTimes.at(process->processNum) += 1;

            if(runTimes.at(process->processNum) == process->serviceTime) {
                totalTimes.at(process->processNum) = currentTime - process->arrivalTime;
                avgTime += currentTime - process->arrivalTime;
                priorityQueue[queueIndex].pop();
                timeMap.erase(process);
                procsCompleted += 1;
            }
            else {
                if(queueIndex == 0) {
                    priorityQueue[0].pop();
                    priorityQueue[0].push(process);
                }
                else {
                    timeMap.at(process) += 1;
                    if(timeMap.at(process) == pow(2, 4 - queueIndex)) {
                        priorityQueue[queueIndex].pop();
                        priorityQueue[queueIndex-1].push(process);
                        timeMap.at(process) = 0;
                    }
                }
            }
        }
    }

    avgTime /= totalTimes.size();

    ofs << std::fixed << std::setprecision(2) << avgTime;
    for(int time: totalTimes) {
        ofs << " " << time;
    }
    ofs << '\n';
}