8th International Conference of Modeling and Simulation - MOSIM’10 - May 10-12, 2010 - Hammamet - Tunisia “Evaluation and optimization of innovative production systems of goods and services”
MINIMIZING THE SUM OF JOB COMPLETION TIMES FOR WASHING OPERATIONS IN HOSPITAL STERILIZATION SERVICES Onur Ozturk, Maria Di Mascolo, Marie-Laure Espinouse Laboratoire G-SCOP (Grenoble-Science pour la Conception, l’Optimisation et la Production) UMR5772, CNRS, Grenoble INP, UJF Grenoble, France {onur.ozturk; maria.di-mascolo, marie-laure.espinouse;}@g-scop.grenoble-inp.fr
Alexia Gouin GIPSA-lab (Laboratoire Grenoblois de l’Image, de la Parole, du Signal et de l’Automatique) UMR 5216, CNRS, Grenoble INP, UJF Grenoble, France
[email protected]
ABSTRACT: In this paper, we deal with the problem of minimizing the sum of completion times for washing operations in hospital sterilization services. After use in operating rooms, reusable medical devices (RMD) are sent to the sterilization service which is composed of various processes. In the washing step, different sets of RMD, used for different operations, may be washed together without exceeding washer capacity. For organizational reasons, we are not allowed to split RMD sets. So, we consider a batch scheduling problem where RMD sets may have different sizes and different release dates for washing. Note that if all release dates are equal, the problem may be reduced to a bin packing problem. We provide a mixed integer linear programming model which aims at minimizing the sum of completion times for washing cycles. We provide and also experiment some heuristics based on classical bin packing algorithms. KEYWORDS: Hospital Sterilization Service; Reusable Medical Device; Batch scheduling; Bin Packing problem; Heuristics; Mixed Integer Linear Programming
1
INTRODUCTION
Hospital sterilization services aim at eliminating all infectious risks subject to the use of medical devices in surgical operations. Their most important objective is to prevent nosocomial infection. Sterilization enables the reuse of medical devices in the next coming surgeries. After each use, sterilization guarantees the desired hygiene level of reusable medical devices (RMD) for other uses in operating rooms. RMD can be defined as instruments used in surgeries that can be re-used. Beside sterilization concern, in fact like all other sectors, hospitals are facing increased costs in their services, logistics or purchasing activities. Respecting hygiene conditions, increasing the number of reusable medical devices sterilized per day may help to cut costs about the purchasing of these equipments. In this paper, we explore opportunities for a better grouping of RMD sets for the washing step in a sterilization service. Due to a great number of surgeries and to a capacity constraint of washers, the washing step is generally a bottleneck over all the sterilization service (Reymondon et al.2008). Our aim is to minimize the sum of RMD washing completion times by optimizing the fulfillment of washers. Effective washing step scheduling by minimizing the sum of RMD washing completion
times helps to minimize the waiting of RMD in front of washers, which is important for hygiene conditions of RMD (Ngo Cong, 2008). This criterion can also be seen as minimizing the throughput (RMD quantity) in the washing step. 1.1 Sterilization process Sterilization process is regulated by some quality standards (see (AFNOR, 2005) for French quality standards for RMD sterilization). Sterilization is a cyclic process (Fig.1) which is composed of several steps. Starting from the use in operating rooms, RMD are sent to sterilization service and pass the following steps: pre-disinfection, rinsing, washing, verification, packing, sterilization, storage and reuse in operating rooms (Reymondon et al., 2008). After use for a surgical operation, RMD are directly put in a chemical substance, which enables pre-disinfection. They are then transferred to the sterilization service. There, they are firstly rinsed, and then washed in washers. Sometimes, rinsing is included in the washers. After washing, RMD are verified and packed into corresponding boxes. All items must be packed individually or grouped into boxes before sterilization. Then, they are sterilized in so-called “autoclaves”, before being transferred to operating rooms and stored before reuse.
MOSIM’10 - May 10-12, 2010 - Hammamet - Tunisia
time p, but may have different release dates rj; and different sizes wj. We aim to schedule the jobs on identical parallel batch processing machines without pre-emption. A machine can simultaneously process more than one job as long as its capacity is not exceeded. Our aim is to minimize the sum of job completion times. 1.3
Figure 1: Sterilization Cycle 1.2 Problem of fulfillment of washers The number of different types of RMD is generally very high and for a typical hospital, there may be hundreds of RMD references. RMD used for a surgical operation constitutes the RMD set for this surgery. Because each surgery may require different numbers and types of RMD, sets may be of different sizes. Moreover, RMD sets are composed of boxes and bags that contain the medical devices. Boxes (and also bags) differ from each other according to the medical devices they contain. For different reasons (surgery characteristics, predisinfection procedure, organization…), RMD sets are ready for washing at different moments. In the washing step, RMD sets cannot be split because of some hygiene and traceability reasons. Another reason is that, in case a splitting is done, it may take a long time to reassemble the boxes and bags of the RMD set identically due to the multiplicity of RMD references. More than one set may be put into a washer without exceeding machine capacity. The decisions to make are then which sets to put together in order to constitute a batch for the washing, and when to launch a washing cycle. Different performance criteria may be considered for washing operations, like maximizing the load of washers (or minimizing the number of launched washing cycles), minimizing the washing completion time (Makespan), or minimizing the sum of RMD washing completion times. In our study, we take this latest as the criterion to optimize. To the best of our knowledge, Albert et al. (2008) are the first ones who studied the problem of fulfillment of washers. In their work, the authors test different fulfillment strategies, like launching a washing cycle when a predetermined machine capacity is reached or when RMD wait at most for a predetermined time, or a combination of both strategies. The problem of fulfillment of washers can be identified to a batch scheduling problem where all jobs may have different sizes, different release dates and equal processing times. More formally, if we make a connection with scheduling problems, we are given a list of jobs L = (j1, j2,…, jn), all of which have the same processing
Literature Review
In the scheduling literature, batch scheduling problems may be divided into two groups: serial batching and parallel batching (Potts and Kovalyov, 2000). In the serialbatching, jobs may be batched if they share the same setup on a machine and the processing time of a batch is equal to the sum of processing times of all jobs in that batch (i.e. one job is processed at a time) (Coffman et al., 1990). In parallel batching, several jobs may be processed at the same time and the processing time of a batch is equal to the greatest processing time of jobs in that batch (Mathirajan and Sivakumar, 2006b). Still, it is possible to divide parallel batching problems into groups according to job sizes or job families. For the classification according to job sizes, we can have two sub-groups: jobs requiring one unit of machine capacity (Lee et al., 1992), or jobs having different capacity requirements (jobs having different sizes) (Uzsoy, 1994). Note that for this last one, if all release dates are equal, it can be possible to define the same problem as a bin-packing problem according to the criteria to optimize. If the problem is subject to job families, we shall say that all the jobs in the same family have the same processing time, but may have different sizes and release dates (Azizoglu and Webster, 2001). If batches are limited to jobs from a single job family, we speak of incompatible job families; else, we have compatible job families (or a single job family). Clearly, our problem is a parallel batching problem with different job sizes and a single job family. In parallel batching problems with different job sizes, the sum of job sizes that are put into a batch should not exceed machines capacity. Each job is assigned to just one batch. The processing time of a batch is given by the longest processing time of jobs that are put into that batch. If we speak of job families, batches are constituted only of jobs from the same family. In tables 1 and 2, we give a brief classification of the literature dealing with parallel batch scheduling problems with different job sizes in presence of a single job family and several job families, respectively. The articles are sorted according to the publication year. In the second and third column, we give a brief description of the problems and the proposed solution methods. The fourth column is for the objective function. We understand from table 1 that most of the studies focus on minimizing the makespan on a single parallel batch processing machine (or BP, machine that can process several jobs simultaneously), and except for two articles, the job release dates are always taken as equal. In table 2, we see various objective functions for the problem when job families are considered.
MOSIM’10 - May 10-12, 2010 - Hammamet - Tunisia
Objectives: Makespan: 1; total completion time: 2; total weighted comp. time: 3; mean flow time: 4
Ref. Uzsoy (1994) Ghazvini and Dupont (1998)
Azizoglu and Webster (2000) Zhang et al. (2001)
Dupont and DhaenensFlipo (2002)
Problem Single BP, different job sizes and processing times, identical release dates. Single BP, different job sizes and processing times, identical release dates. Number of jobs in batch is limited. Single BP, different job sizes, processing times and job weights, identical release dates. Single BP, different job sizes and processing times, identical release dates. Single BP, different job sizes and processing times, identical release dates.
Algorithm Obj Heuristic algo- 1, 2 rithms and a B&B procedure Heuristics 4
B&B
3
Approximation 1 algorithms
B&B
1
Single BP, different MILP model, 1 job sizes and process- Simulated aning times, identical nealing release dates. Li et al. Single BP, different Approximation 1 (2005) job sizes, processing algorithms times and release dates. Single BP, different Generic algo- 1 Kashan et job sizes and process- rithms al. (2006) ing times, identical release dates. Xu and Parallel identical BP, MILP model, 1 Bean different job sizes genetic algo(2007) and processing times, rithm identical release dates. Damodaran Single BP, different MILP model, 1, 4 et al. job sizes and process- Simulated an(2007) ing times, identical nealing release dates. Kashan et Parallel identical BP, Lower bound 1 al. (2008) different job sizes algorithm, and processing times, genetic algoidentical release rithm dates. Chung et Parallel identical BP, MILP model, 1 al.(2009) different job sizes, heuristics processing times and release dates. Table 1: A review for parallel batching problems with different job sizes and a single job family Melouk et al. (2004)
Objectives: Makespan: 1; total completion time: 2; total weighted comp. time: 3; mean flow time: 4; weighted flow time: 5; total weighted tardiness: 6; Maximize used machine capacity: 7
Ref.
Problem Single BP, different Kempf et job sizes, weights al.(1998) and processing times, identical release dates. Azizoglu, and Single BP, different Webster job sizes and proc(2001) essing times, identical release dates.
Algorithm Obj. Exact and 1,2 approximate solution procedures Branch and 3 Bound algorithm
Dobson and Single BP, different MILP mo- 5 Nambimadom job sizes, weights del, heuris(2001) and processing times, tics identical release dates. Matharijan et Parallel and nonHeuristic 6 al. (2006a) identical BPs, differ- algorithms ent job sizes, priorities, processing times, release dates Matharijan et Parallel and nonHeuristic 7 al. (2007) identical BPs, differ- algorithms ent job sizes, priorities, processing times, release dates Table 2: A review for parallel batching problems with different job sizes and job families Let us consider now the papers dealing with the job completion time. Uzsoy (1994) studies a batch scheduling problem where jobs have equal release dates but different processing times. He works on the problem of minimizing the makespan and the sum of job completion times, which are proven both to be NP-hard, on one machine. He provides several heuristic algorithms which are based on first fit algorithm for the minimization of the makespan and a branch and bound algorithm for the minimization of sum of job completion times. Azizoglu and Webster (2000) develop a branch and bound algorithm to minimize the total weighted completion time on a single batch processing machine in presence of different job processing times, job sizes and job weights (or job importance) while all release dates are equal. In (Azizoglu and Webster, 2001), the authors extend the problem with job families. They aim to minimize the total weighted completion time on a single parallel batching machine. Each job has a different processing time, weight and size, while all release dates are equal. They propose a Branch and Bound algorithm that finds the optimal solution in 30 minutes up to 25 jobs. Kempf et al. (1998) study the problems of minimizing the makespan and the total completion time on a single parallel batching machine with job families. In their problem, jobs have different processing times and sizes, but equal release dates. As the secondary resource, jobs are put onto boards for the execution and the number of boards used for a job is a function of the job size. The
MOSIM’10 - May 10-12, 2010 - Hammamet - Tunisia
total number of boards put in the machine should not exceed a certain limit. They provide a MILP model and several heuristics for both the minimization of the makespan and the sum of job completion times.
machine capacity. Finally ∑Cj refers to the sum of jobs completion times, i.e. the criterion to optimize.
In this paper, we deal with the problem of minimizing the sum of job completion times on parallel identical batch processing machines (the washers) subject to differrent job (the RMD) release dates and different sizes. To the best of our knowledge, all work done for minimizing the sum of job completion times with job sizes consider equal job release dates. However, in our problem, job release dates may be different. In section two, we first give a formal description and then a mixed integer linear programming (MILP) model for our problem. As the MILP model is not sufficient for large instances of the problem, in section three, we develop heuristics based on classical bin packing problem heuristics. Section four is dedicated to experimental design.
Uzsoy (1994) studies the complexity of the problem 1/p-batch, pj =p, wj, B/∑Cj. He shows that when jobs release dates and processing times are the same for all jobs, the problem is NP-hard. As this special case of our problem is NP-hard, the problem we treat is also NPhard.
2
PROBLEM DESCRIPTION AND MODELING
In this section, we give a formal description of our problem. Afterwards, the complexity of the problem is given and a mixed integer linear programming approach is explained. 2.1 Problem Description We identify the problem of fulfillment of washing resources as a batch scheduling problem. So in the following, RMD sets are denoted as jobs and washers as batching machines. We make the following assumptions: • • • • •
•
There are n jobs to be processed. The release date for job j is denoted by rj and processing times are equal for all jobs and denoted by p. All machines have the same capacity B and the size of a job j is wj. We assume that the size of a job cannot be greater than the machine capacity. Several jobs can be batched together respecting the machine capacity constraint. Once a processing for a batch is started, it cannot be interrupted. We are interested in a parallel batching problem where the processing time of a batch is equal to the longest processing time of jobs in that batch. As all the jobs in our problem have the same processing time, p, the processing time of any batch is p. We are not allowed to split a job into several batches.
Inspired from the three fields Graham’s notation (Graham et al., 1979), we propose the following notation for our problem: P/p-batch, rj, pj = p, wj, B/∑Cj. In this notation, P stands for identical parallel machines, p-batch for parallel batching, rj and wj for job release date and size, respectively, pj = p for equal processing times and B for
2.2
2.3
Complexity
Mixed Integer Linear Programming Model
The problem under study can be formulated as an integer linear program. Index: j: 1,…,N for jobs k: 1,…,N for batches m: 1,…,M for machines Parameters: wj: size of job j rj: release date of job j N: number of jobs B: machine capacity p: processing time of jobs and batches Q: a big number Decision variables: xjk: 1 if job j is executed in batch k, 0 otherwise ykm: 1 if batch k is created on machine m, 0 otherwise zkk’: 1 if batches k and k’ are assigned to the same machine, 0 otherwise Sk: start time of batch k Cj: end of processing for job j Mathematical Formulation:
MOSIM’10 - May 10-12, 2010 - Hammamet - Tunisia
Our objective is to minimize the sum of jobs completion times. At most “N” batches can be created in a schedule. So, the index for batches is from 1 to N. These batches could be real batches (which contain jobs) or dummy batches (empty batches) Constraint (1) ensures the assignment of all jobs to a batch. Constraint (2) is the capacity constraint. Constraint (3) assigns all the batches to a machine. With constraint (4), if two batches k and k’ are scheduled on the same machine, variable zkk’ is forced to be equal to one. When no dummy batches are scheduled on different machines, then, thanks to constraints (6), (7), and the objective function, variable zkk’ is set to 0 Constraint (5) sets the start time of a batch as greater than the release date of jobs in that batch. In case more than one batch is assigned to a machine, (6) ensures a difference at least equal to the execution duration p, between the starting time of these batches. Constraint (7) defines the completion time for a job, as the starting time of the batch in which it is included plus the execution duration, p. In the model, the total number of variables is 3*(N²+N)/2+ N*M and the total number of constraint equations is 2N²+3N+N(N-1)(M+1)/2. In section 4, the MILP model is implemented using CPLEX 10.2 on a number of test instances. 3
HEURISTIC APPROACHES
In this section, we present several heuristics. The first one creates batches with successive jobs and it can be seen as an adaptation of a FIFO policy. The others can be considered as an adaptation of the classical binpacking heuristics, which are first fit (FF), best fit (BF), and worst fit (WF), taking into account job release dates. In our bin-packing based heuristics, we first divide the given time horizon into intervals of length p, then for each interval, we apply a modified version of classical bin packing heuristics. The reason of this procedure is that, creating batches within time intervals of length p enables to form batches with jobs whose difference between release dates are at most equal to p. Hence, we prevent from batching early jobs with late jobs. (For all heuristics, we suppose that jobs are presorted and numbered in non-decreasing order of jobs release dates.) 3.1 FIFO based heuristic (FB) In this heuristic, jobs are first sorted in increasing order of release dates. Then, we place jobs consecutively into the open batch. If the next job does not fit in, the batch is closed and a new batch is opened for the job. 3.2 Interval Modified First Fit heuristic (IMFF) This heuristic operates by first dividing the time slot, in which jobs arrive, into intervals that are equal to a processing time, p (see step 1). Then, for each time interval, the heuristic operates by first creating a list of jobs, L1, sorted in increasing order of jobs release dates.
FB heurıstic 1 Let L1 be the set of jobs sorted in increasing order of jobs release dates : rj 2 While L1 is not empty 2.1 Choose the job at the head of the list L1, place it to the open batch. If it does not fit, close the current batch and create a new batch for the item. 2.2 Update L1. End while 3 Set ready time of each generated batch as the greatest release date of jobs contained in the batch 4 Sequence batches consecutively onto machines in increasing order of their ready time. Each time a new batch is formed, we try to insert each job into the created batch respecting the batch capacity and the order of list L1. If there are still un-batched jobs, we create another batch and carry out the same operation until all jobs in an interval are batched. Note that, for the rest of the heuristics, r1 and rN are the release dates of the first and the last element of the presorted job list (presorted and numbered in increasing order of jobs release dates). IMFF heuristic 1 Set no_int the smallest integer bigger than (rN-r1)/p 2 Put the jobs whose release date is 0 in a list L1. 3 For i = 1 to no_int 3.1 Add to list L1 jobs whose release dates are in interval ](i − 1) * p, i * p ] 3.2 Sort the jobs of L1 in increasing order of job release dates, rj 3.3 While L1 is not empty 3.3.1 Choose the item at the head of the list L1 and place it to the first batch it fits. If it fits in no batch, create a new batch for the item. 3.3.2 Update L1. End while 3.4 i=i+1 End for 4 Set ready time of each generated batch as the greatest release date of jobs contained in the batch 5 Sequence batches consecutively onto machines in increasing order of their ready time.
3.3 Interval Modified Best Fit heuristic (IMBF) This heuristic operates by first dividing the time slot, in which jobs arrive, into intervals that are equal to a processing time, p. Then, for each interval, the heuristic creates a list of jobs, sorted in increasing order of jobs release dates, and another list of jobs sorted in decreasing order of jobs sizes. Each time a batch is created, the first list gives its first element to the batch. Then, the second list is scanned from its first element, and we try to assign jobs to the batch having the smallest residual capacity.
MOSIM’10 - May 10-12, 2010 - Hammamet - Tunisia
IMBF heuristic 1 Set no_int the smallest integer bigger than (rN-r1)/p 2 Put the jobs whose release date is 0 in a list L1. 3 For i = 1 to no_int 3.1 Add to list L1 jobs whose release dates are in interval ](i − 1) * p, i * p ] 3.2 Sort the jobs of L1 in increasing order of job release dates, rj 3.3 Sort the jobs of L1 in decreasing order of jobs sizes wj : L2 3.4 While L1 is not empty 3.4.1 Put the first job of L1: jk in a new batch: Bk 3.4.2 Erase job jk from lists L1 and L2 3.4.3 For each element: jl of L2 3.4.3.1 If jl fits the batch Bk then Bk = Bk ∪ jl Erase jl form lists L1 and L2 End if End for End while 3.5 i=i+1 End for 4 Set ready time of each generated batch as the greatest release date of jobs contained in the batch 5 Sequence batches consecutively onto machines in increasing order of their ready time.
IMWF heuristic 1 Set no_int the smallest integer bigger than (rN-r1)/p 2 Put the jobs whose release date is 0 in a list L1. 3 For i = 1 to no_int 3.1 Add to list L1 jobs whose release dates are in interval ](i − 1) * p, i * p ] 3.2 Sort the jobs of L1 in increasing order of job release dates, rj 3.3 Sort the jobs of L1 in increasing order of jobs sizes wj : L2 3.4 While L1 is not empty 3.4.1 Put the first job of L1: jk in a new batch: Bk 3.4.2 Erase job jk from lists L1 and L2 3.4.3 For each element: jl of L2 3.4.3.1 If jl fits the batch Bk then Bk = Bk ∪ jl Erase jl form lists L1 and L2 End if End for End while 3.5 i=i+1 End for 4 Set ready time of each generated batch as the greatest release date of jobs contained in the batch 5 Sequence batches consecutively onto machines in increasing order of their ready time.
3.4 Interval Modified Worst Fit heuristic (IMWF)
4.1
Similar to the “interval modified best fit” heuristic, once the time intervals and the jobs that correspond to each interval are determined, this heuristic apply a worst fit algorithm to place jobs into batches. For each interval, the heuristic creates two lists of jobs: one list in which jobs are sorted in increasing order of jobs release dates, a second list where jobs are sorted in increasing order of jobs sizes. Each time a batch is created, the first list gives its first element to the batch. Then, the second list is scanned from its first element, and we try to assign jobs to the batch having the biggest residual capacity.
We create random and real case inspired instances. For this second one, we use data given by a private French hospital. More precisely, the machine capacity, batch processing time and some instances are inspired from the real case. The machine capacity is assumed to be 6 and the processing time is 60 minutes. In real case inspired instances, job sizes vary uniformly between 0.5 and 4 and there may be 0 to 40 minutes of difference between jobs release dates. We group our experiments into sets according to the number of jobs and the number of machines. The number of machines varies from 1 to 4, while the number of jobs is successively 5, 10, 15, 30, 50 and 70. Note that depending on the size of hospitals, it is possible to have such numbers of washers and RMD sets in a day (Ngo Cong 2009). For each job number/machine number combination, we test 90 different instances. The instances are defined with three types of jobs sizes and three types of job release dates. For any job number/machine number combination, number of test instances and instance characteristics are shown on table 3.
4
NUMERICAL EXPERIMENTATION
In the first part of this section, we make several tests for the MILP model and for the proposed heuristics. Firstly, we test the MILP model using a commercial optimization program, CPLEX, and compare the results with those given by the proposed heuristics. As the MILP model is not adequate enough for big instances of the problem, heuristics are compared among themselves for the case where no optimal solution is found in reasonable time by CPLEX. In the second part, the general strategy adopted for washing operations in hospital sterilization services is evaluated.
Tests for the MILP model and the heuristics
An Intel Corel 2 Duo, 3 Ghz CPU computer with 3.25 GB Ram is used for all computational experiments. All heuristics are coded in C++ language, and CPLEX version 10.2 is used to implement the MILP model.
MOSIM’10 - May 10-12, 2010 - Hammamet - Tunisia
Jobs sizes
Jobs release Inspired dates from the real case
20 min. between release dates
40 min. between release dates
Inspired from the real case
10 tests
10 tests
10 tests
Random and smaller than half of machine capacity
10 tests
10 tests
10 tests
Totally random
10 tests
10 tests
10 tests
Table 3: Instance characteristics and number of tests for different “job number/machine number” combinations For small instances, we compare heuristic results to the optimal ones found by CPLEX. Numerical experiments show that for any instance with one machine case, optimal solution can be reached within a reasonable time when there are 5 and 10 jobs. For the case with 10 jobs, when the number of machines is greater than one, the execution time may not be reasonable for finding the optimal solution. Thus, we fix a maximum execution time, 60 minutes, which is equal to the processing time of batches, and we make a comparison with the optimal results if found within 60 minutes. Table 4 shows the average gap between optimal and heuristic results in terms of solution quality and also mean execution times in seconds for CPLEX results. The gap reported for heuristics is given by [∑Cj(heuristic) - ∑Cj (optimal)] / ∑Cj (optimal) . Heuristic execution times are equal to some milliseconds for 5 and 10 jobs instances, and less than one second for other instances. Average gap in % between optimal and heuristic results Number of jobs
5 jobs
10 jobs
Number of machines
Average CPLEX resolution time
solution. However, the performance of other heuristics are not so different from each other for the criterion of reaching the optimal solution. For the rest of small and large instances, we compare the heuristics among themselves. For each number of machines and number of jobs, we try to see which heuristic gives mostly the best solution. Number Number of of jobs machines 5 jobs
10 jobs
FB
IMBF
IMWF
IMFF
1 mach
20
10
12
20
2 mach
8
8
8
35
3 mach
3
2
2
14
4 mach
0
2
2
13
1 mach
2
2
2
4
Table 5: Percentage of cases for which heuristics reach the optimal solution Number Number of jobs of machines 10 jobs 2 mach
15 jobs
30 jobs
50 jobs
FB
IMBF
IMWF
IMFF
28
52
48
74
3 mach
26
47
45
78
4 mach
26
47
45
81
1 mach
56
28
23
38
2 mach
20
45
40
78
3 mach
11
40
38
90
4 mach
13
38
38
88
1 mach
66
22
23
32
2 mach
18
41
43
77
3 mach
10
34
34
91
4 mach
10
35
34
90
1 mach
68
13
11
30
FB
IMBF
IMWF
IMFF
1 mach
9.4
10.8
9.2
6.8
