modify the code:

import java.util.PriorityQueue;

import java.util.Queue;

import java.util.Random;

import java.util.concurrent.Semaphore;

public class hw$3\_$Soto $\{$

static class Process $\{$

String processID;

int priority;

int timeLeft;

public Process$($String processID, int priority, int timeLeft$)\{$

this.processID $=$ processID;

this.priority $=$ priority;

this.timeLeft $=$ timeLeft;

$\}$

@Override

public String toString$()\{$

return processID $+"$:$"+$ priority;

$\}$

public int getTimeLeft$()$

$\{$

return this.timeLeft;

$\}$

$\}$

public static void main$($String$[]$ args$)\{$

Random rand $=$ new Random$()$;

Semaphore semaphore $=$ new Semaphore$(1)$;

PriorityQueue priorityQueue $=$ new PriorityQueue$<>(($p$1,$ p$2)->$ p$1.$priority $-$ p$2.$priority$)$;

Queue blockingQueue $=$ new PriorityQueue$<>(($p$1,$ p$2)->$ p$1.$priority $-$ p$2.$priority$)$;

$//$ Generate $10$ processes and add them to the long$-$term queue

for $($int i $=1$; i $<=10$; i$++)\{$

String processID $="$P$"+$ i;

int priority $=$ rand.nextInt$(20)+1$;

int timeLeft $=$ priority $*100$; $//$ Adjust time unit if necessary

priorityQueue.add$($new Process$($processID$,$ priority, timeLeft$))$;

$\}$

int stepCounter $=0$;

while $(!$priorityQueue.isEmpty$()||!$blockingQueue.isEmpty$())\{$

try $\{$

semaphore.acquire$()$; $//$ Acquire semaphore to start processing

Process nextProcess $=$ null;

System.out.println$("$Step: $"+$ stepCounter$)$;

stepCounter$++$;

printPriorityQueue$($priorityQueue$)$;

printBlockedQueue$($blockingQueue$)$;

if $(!$priorityQueue.isEmpty$()$ && blockingQueue.size$()<=5)\{//$ adding processes to the blocking queue

nextProcess $=$ priorityQueue.poll$()$;

System.out.println$("$Dispatching from priority queue: $"+$ nextProcess$)$;

for $($int i $=0$; i $<4$ && $!$priorityQueue.isEmpty$()$; i$++)\{$

Process processToAdd $=$ priorityQueue.poll$()$;

blockingQueue.add$($processToAdd$)$;

$\}$

$\}$ else if $(!$blockingQueue.isEmpty$())\{//$ dispatch processes from the blocking queue to the processor

nextProcess $=$ blockingQueue.poll$()$;

System.out.println$("$Dispatching from blocking queue: $"+$ nextProcess$)$;

$\}$

if $($nextProcess $!=$ null$)\{$

process$($semaphore$,$ nextProcess, blockingQueue$)$;

$\}$ else $\{$

semaphore.release$()$; $//$ Release semaphore if no process to execute

$\}$

$\}$ catch $($InterruptedException e$)\{$

e$.$printStackTrace$()$;

$\}$

$\}$

$\}$

private static void process$($Semaphore semaphore, Process process, Queue blockingQueue$)\{//$ simulates executing in the processor

new Thread$(()->\{$

try $\{$

System.out.println$("$Running process: $"+$ process.toString$())$;

Thread.sleep$($process$.$getTimeLeft$())$;

System.out.println$("$Process completed: $"+$ process.toString$())$;

System.out.println$("-----------------------")$;

$\}$ catch $($InterruptedException e$)\{$

e$.$printStackTrace$()$;

$\}$ finally $\{$

semaphore.release$()$; $//$ Release semaphore once processing is done

$\}$

$\}).$start$()$;

$\}$

public static void printPriorityQueue$($PriorityQueue queue$)//$ prints the priority queue

$\{$

System.out.print$("$The processes in the Priority queue are: $")$;

for $($Process p : queue$)$

$\{$

System.out.print$($p$.$toString$()+"")$;

$\}$

System.out.println$()$;

$\}$

public static void printBlockedQueue$($Queue queue$)//$ prints blocked queue

$\{$

System.out.print$("$The processes in the blocked queue are: $")$;

for $($Process p : queue$)$

$\{$

System.out.print$($p$.$toString$()+"")$;

$\}$

System.out.println$()$;

$\}$

$\}$

to where only five processes at most can be in the blocked queue