#include <stdio.h>
#include <stdlib.h>
#include <math.h>


#include "aloca.h"
#include "om.h"
#include "sbd.h"
#include "sb.h"
#include "sbtools.h"
#include "sodl.h"
#include "longest.h"

/*
 *
 */

STORE_DATA(
     long *actrelease ,
     long iq ,
     long *jobs ,
     long *releases ,
     long *processing_time ,
     long *tails ,
     long *moddeadline ,
     long *machine_total ,
     long solve_with_deadlines )
{ 
  long j , j1;
  long k , k1 ; 
  
  
  *jobs = machine_total[iq] ;
  for (j=1;j<=*jobs;j++) {
      k           = machine_operations[iq][j] ; 
      release[j]  = releases[ k ] ; 
      tail[j]     = tails[ k ] ;
      pt[j]       = processing_time[ k ] ; 
      deadl[j]    = moddeadline[ k ] ;
     // if ((deadl[j] < 0) && (solve_with_deadlines)) { 
     //   printf("error ...  deadl , solve_with_deadlines =  %ld \n",
       //        solve_with_deadlines) ; 
	//	printf("deadline = %ld - machine = %ld , oper = %ld \n",
	//		deadl[j],
	//		iq,
	//		j) ; 
		
        /*exit(1) ; */
     // }
    }
   
   setup_onemachine[0][0] = 0 ; 
  for (j=1;j<=*jobs;j++) { 
	  k = machine_operations[iq][j] ;
	  setup_onemachine[0][j] = setup_oper[0][k] ; 
	  setup_onemachine[j][0] = 0 ; 
	  for (j1=1;j1<=*jobs;j1++) {
            k1 = machine_operations[iq][j1] ;
            setup_onemachine[j][j1] = setup_oper[k][k1] ; 
	  }
  }


 /* jbefore = 0 ; 
  kbefore = 0 ; 
 
  for (j=1;j<=*jobs;j++) { 
      k           = machine_operations[iq][j] ; 
      if (actrelease[k]) { 
        if (jbefore) { 
		  
          delay[jbefore][j] = actrelease[k] - actrelease[kbefore] ; 
          tsucco[jbefore] = tsucco[jbefore] + 1 ; 
          tpredo[j] = tpredo[j] + 1 ; 
          succo[jbefore][tsucco[jbefore]] = j ; 
          predo[j][tpredo[j]] = j ; 
          jbefore = j ; 
          kbefore = k ; 
        }
        else { jbefore = j ; kbefore = k ;  }
      }
  }
  */

}

/* 
 * 
 */

STORE_SOLVE_PROBLEMS(
     long machi ,
     long *jobs ,
     long *actrelease ,
     long *releases ,
     long *processing_time ,
     long *tails ,
     long *moddeadline ,
     long *machine_total ,
     long *which_machine ,
     long *position ,
     long oper ,
     long *jobsucc ,
     long *macsucc , 
     long finishing ,
     long *labelled_list ,
     long *jobpred ,
     long *macpred , 
     long *optimal_makespan ,
     long solve_with_deadlines ,
     long *bmksp ,
     long status ) 
{
  long n , i , j , k;
  long count_pred ; 
  long my_order[1000] ; 

  STORE_DATA(actrelease,
             machi,
             jobs,
             releases,
             processing_time,
             tails, 
             moddeadline,
             machine_total,
             solve_with_deadlines) ; 

  CHECK_DEPENDENCIES(machi,
                     which_machine,
                     processing_time,
                     position,
                     machine_total,
                     oper,
                     jobsucc,
                     macsucc,
                     finishing,
                     labelled_list,
                     jobpred,
                     macpred) ; 

   predlist[0]= 0 ; 
   predlist[1] = 0 ; 

   count_pred = 0 ; 

   for (i=1;i<=*jobs;i++) { 
	   if (tpredo[i] != 0) { 
		   predlist[count_pred] = i ; 
		   count_pred++ ; 
		   for (j=1;j<=tpredo[i];j++) { 
             predlist[count_pred] = predo[i][j] ;
			 count_pred++; 
			 predlist[count_pred] = delay[predo[i][j]][i] ; 
			 count_pred++; 

		   }
		   predlist[count_pred] = 0 ; 
		   count_pred++ ;
	   } 
             

   } 
   predlist[count_pred] = 0 ; 

//   for (i=0;i<=count_pred;i++) printf("%ld \n",predlist[i]) ; 






  *optimal_makespan = ((long) RAND_MAXI) ; 
  n = *jobs ; 
  if (solve_with_deadlines) { 
//    printf("Solve problem with deadlines \n") ;   
    onemachinesetup(n, 
		optimal_makespan) ;
	/*
                    solve_with_deadlines,
                    bmksp,
                    0) ; */
  }
  else { 
  //  printf("Solve problem without deadlines \n") ; 
    onemachinesetup(n,optimal_makespan);
               
		
		/*optimal_makespan,
               solve_with_deadlines,
               bmksp,
               status) ; */
  }


 
  for (i=1;i<=*jobs;i++) 	  my_order[order[i]] = i ; 

  
   for (i=1;i<=*jobs;i++) { 
	   if (tpredo[i] != 0) { 
		   for (j=1;j<=tpredo[i];j++) { 
             k = predo[i][j] ; 
			 if (my_order[k] > my_order[i])
			 {printf("Error in ordering %ld %ld \n",k,i) ;}

		   }
		 
	   } 
   } 
}


/*
 *
 */

FIND_BOTTLENECK(
     long solve_with_deadlines ,
     long m ,
     long *bottleneck_machine ,
     long *bmksp ,
     long *machine_sched ,
     long *actrelease ,
     long *releases ,
     long *processing_time ,
     long *tails ,
     long *moddeadline ,
     long *best_order ,
     long *machine_total ,
     long *which_machine , 
     long *position ,
     long oper ,
     long *jobsucc ,
     long *macsucc ,
     long finishing ,
     long *labelled_list ,
     long *jobpred ,
     long *macpred )
{
  long i , ij ;
  long jobs ; 
  long optimal_makespan ;
  long status ; 
  
  *bmksp = 0 ;
  *bottleneck_machine  = 0 ;

  status = 0 ; 
  
  for (i=1;i<=m;i++) {
    if  (machine_sched[i]==0){ 

            STORE_SOLVE_PROBLEMS(i,
                           &jobs,       
                           actrelease,
                           releases,
                           processing_time, 
                           tails,
                           moddeadline,
                           machine_total,
                           which_machine,
                           position,
                           oper,
                           jobsucc,
                           macsucc,
                           finishing,
                           labelled_list,
                           jobpred,
                           macpred,
                           &optimal_makespan,
                           solve_with_deadlines,
                           bmksp,
                           status) ; 

	 
			infmachines[i] = 0 ; 

			  
			if (INFEASIBLE) { infmachines[i] = 1 ; } 

		//	printf("Machine : %ld has makespan  %ld \n",i, optimal_makespan) ; 
      if  (optimal_makespan > *bmksp) { 
        *bmksp = optimal_makespan  ;
        *bottleneck_machine  = i  ;
        for (ij=1;ij<=jobs;ij++) { best_order[ij] = order[ij] ; }
      }
    }
  }
}
   

/*
 *
 */
     
FIND_BOTTLENECK_DELETION(
     long solve_with_deadlines  ,
     long m ,
     long *bottleneck_machine ,
     long *bmksp ,
     long *machine_sched ,
     long *actrelease ,
     long *releases ,
     long *processing_time ,
     long *tails ,
     long *moddeadline ,
     long *best_order ,
     long *machine_total ,
     long *which_machine , 
     long *position ,
     long oper ,
     long *jobsucc ,
     long *macsucc ,
     long *deleted , 
     long finishing ,
     long *labelled_list ,
     long *jobpred ,
     long *macpred )
{ 
  long i  ; 
  long ij ; 
  long optimal_makespan ; 
  long jobs ; 
  long status ; 

  *bmksp = 0 ;
  *bottleneck_machine  = 0 ;
  status = 0 ; 
  
  for (i=1; i<= m;i++) { 
    if  (( machine_sched[i] == 0 ) && (deleted[i] == 1)) { 
      STORE_SOLVE_PROBLEMS(i,
                           &jobs,
                           actrelease,
                           releases,
                           processing_time, 
                           tails,
                           moddeadline,
                           machine_total,
                           which_machine,
                           position,
                           oper,
                           jobsucc,
                           macsucc,
                           finishing,
                           labelled_list,
                           jobpred,
                           macpred,
                           &optimal_makespan,
                           solve_with_deadlines,
                           bmksp,
                           status) ;

      if  ( optimal_makespan > *bmksp )    {
        *bmksp = optimal_makespan  ;
        *bottleneck_machine  = i  ;
        for (ij=1;ij<=jobs;ij++) { best_order[ij] = order[ij] ; }
      }
    }
  }
}

/*
 * 
 */

FIND_RANDOMIZED_BOTTLENECK(
     long solve_with_deadlines ,
     long m ,
     long *bottleneck_machine ,
     long *bmksp ,
     long *machine_sched ,
     long *actrelease ,
     long *releases ,
     long *processing_time ,
     long *tails ,
     long *moddeadline ,
     long *best_order ,
     long *machine_total ,
     long *which_machine , 
     long *position ,
     long oper ,
     long *jobsucc ,
     long *macsucc ,
     long *deleted ,
     long finishing ,
     long *labelled_list ,
     long *jobpred ,
     long *macpred )
{
  long i ;
  long j ; 
  long ij ;
 
  long optimal_makespan ; 
  long SELECTED ;
  long solution_number ; 
  long jobs ; 
  long status ; 


  double random_number() ; 

  long the_machines [ MAXMACHINES ] ; 
  long the_order [ MAXMACHINES ] ; 
  long my_makespans [ MAXMACHINES ] ; 
  
  double y , cweight , cbefore , aa ;
  double weights[100] , tweight ;
  
  *bmksp = 0 ;
  *bottleneck_machine  = 0 ;
  
//  printf("In randomized ... m = %ld \n",m) ; 
  solution_number = 0 ; 
  for (i=1; i<= m;i++) {
	  deleted[i] = 1; 
	  //printf("Machine sched = %ld \n",machine_sched[i]) ; 
    if  (( machine_sched[i] == 0 ) && (deleted[i] == 1) )  { 
	//	printf("Machine = %ld \n",i) ; 
      optimal_makespan = 999 ; 
      solution_number++ ;
      my_makespans[solution_number] = optimal_makespan  ; 
      the_machines[solution_number] = i ; 
    }
  }
  
  SORT_KEEP_MAKESPANS(solution_number,
                      the_order,
                      my_makespans) ; 
  aa = 1.0 ; 
  
  for (i=1;i<=solution_number;i++) { 
    j = the_order[i] ; 
    weights[j] = (1.0 / aa) ; 
  }
  
  tweight = 0.0 ;
  for (i=1;i<=solution_number;i++) tweight = tweight + weights[i] ; 
  for (i=1;i<=solution_number;i++)    {  
    j = the_order[i] ; 
    weights[j] = (weights[j] /  tweight) ; 
  }
  tweight = 0.0 ;
  for (i=1;i<=solution_number;i++) tweight = tweight + weights[i] ; 
/*  num = rand() ; 
  y   = num / RAND_MAX ; 
*/

  y = random_number() ;
  
  y =  y * tweight ; 
  cweight = 0.0 ;
  SELECTED = 0 ;  
  
  for (i=1;i<=solution_number;i++) { 
    cbefore = cweight ;
    cweight = cweight + weights[i] ;  
    if ((cbefore <= y) &&
        (y <= cweight)) { SELECTED = i ; 
                          i = solution_number + 100 ; }
  }
  
  if (SELECTED == 0) { 
    printf("Error in randomized bottleneck \n") ; 
    exit(1) ; 
  }
  
  *bottleneck_machine  =  the_machines[SELECTED] ; 
  
  if ((machine_sched[*bottleneck_machine] == 1) 
      || (deleted[*bottleneck_machine] == 0)) {
    printf("Error \n") ; 
    exit(1) ; 
  }
  
//  printf("Selected = %ld \n",*bottleneck_machine) ; 

  i = *bottleneck_machine ; 
  status = 0 ;
  STORE_SOLVE_PROBLEMS(i,
                        &jobs,
                        actrelease,
                        releases,
                        processing_time,
                        tails,
                        moddeadline,
                        machine_total,
                        which_machine,
                        position,
                        oper,
                        jobsucc,
                        macsucc,
                        finishing,
                        labelled_list,
                        jobpred,
                        macpred,
                        &optimal_makespan,
                       solve_with_deadlines , 
                       bmksp , 
                       status) ; 

  *bmksp = optimal_makespan ; 
  for (ij=1;ij<=jobs;ij++) { best_order[ij] = order[ij] ; }
}

/*
 *
 */

SEQUENCE_MACHINE(
     long finishing ,
     long *macsucc ,
     long *macpred , 
     long machi ,
     long *machine_sched ,
     long *best_order ,
     long *position ,
     long *machine_total )
{
  long i , jobi ;
  
  machine_sched[machi] = 1 ;

  for (i=1;i <= machine_total[machi];i++) { 
    order[i] = machine_operations[machi][best_order[i]] ;
  }

  for (i=1;i<= machine_total[machi];i++) {
    machine_operations[machi][i] = order[i] ;
    position[order[i]] = i ;
  }
  
  for (i=1;i<=machine_total[machi];i++) {
    jobi = machine_operations[machi][i] ;
    if (i>1) { macpred[jobi] = machine_operations[machi][i-1] ;  }
    else { macpred[jobi] =  0 ;}

    if (i<machine_total[machi]) { macsucc[jobi] = 
                                    machine_operations[machi][i+1] ; }
    else  { macsucc[jobi] =  finishing ;}
  }
}

/* 
 *
 */


FIND_MAKESPANS(
     long sequenced_machines ,
     long realtasks ,
     long *optimized ,
     long *makespans , 
     long *releases ,
     long *processing_time ,
     long *tails ,
     long *actdeadline ,
     long *machine_total )
{
  long i , j , jobi , makes , PENA ; 
  
  for (i=1;i<=sequenced_machines;i++) {
      makes = 0;
      PENA = 0 ; 
      for (j=1;j<=machine_total[optimized[i]];j++) { 
        jobi = machine_operations[optimized[i]][j] ;
          if (jobi <= realtasks) {
              if (releases[jobi]+processing_time[jobi]+tails[jobi] > makes)
                makes = releases[jobi]+processing_time[jobi]+tails[jobi];
            }
          else {
              if ((releases[jobi] + processing_time[jobi] ) > 
                  actdeadline[jobi])   {
                PENA = PENA + ( ( releases[jobi] + processing_time[jobi] -
                         actdeadline[jobi])*PENALTY) ;}
			  
            }
        }
      makespans[optimized[i]] = makes + PENA ; 
   }
}

/*
 *
 */

SORT_MAKESPANS(
     long m ,
     long sequenced_machines ,
     long *optimized ,
     long *makespans ) 

{ long i , j ;
  long *sorted ;
  long point ;
  long biggest ; 

  sorted = (long *) calloc((m+1),sizeof(long)) ;
  for (i=1;i<=sequenced_machines;i++) {
    /* find the largest makespan */
     biggest = 0 ; 
     for (j=1;j<=sequenced_machines;j++)  {
        if ( sorted[j] == 0 ) {
          if (makespans[optimized[j]] > biggest) { 
            point = j ; 
            biggest = makespans[optimized[j]] ; 
          }
        }
      }
   order[i] = optimized[point] ;
   sorted[point] = 1 ; 
   }
  for (i=1;i<=sequenced_machines;i++) { optimized[i] = order[i] ; } 

 free(sorted) ; 
}

/*
 *
 */

DELETE_MACHINE(
     long mac ,
     long *machine_sched ,
     long *pdc ,
     long *scs , 
     long *machine_total ,
     long finishing ,
               long *macpred ,
     long *macsucc ) 

{
  long ij ;
  long jobi ;

  for (ij=1;ij<=machine_total[mac];ij++) {
    jobi            = machine_operations[mac][ij] ;
    macsucc[jobi]   = finishing ;
    macpred[jobi]   = 0 ;
    pdc[jobi]       = 0 ; 
    scs[jobi]       = finishing ; 
   }
  machine_sched[mac] = 0 ; 
}

/*
 * PRINT_FINAL_SOLUTION() :                            
 */

PRINT_FINAL_SOLUTION(
     long m ,
     long *solved_problems ,
     long realtasks ,
     long *actdeadline ,
     long *releases ,
     long *processing_time ,
     long *machine_total )
{ 
  long i ; 
  long j ;
  long k ; 
  long maxinf ; 
  double max_percent ;

  maxinf = 0 ; 
  max_percent = 0.0 ; 
  for (i=1;i<=m;i++) {
     for (j=1;j<=machine_total[i];j++)  {  
       k = machine_operations[i][j] ; 
       maxinf = MAX(maxinf,(releases[k]+processing_time[k]-actdeadline[k])) ;
       if (max_percent < (((double) maxinf)/ ((double) actdeadline [ k ] ))) 
         max_percent = (((double) maxinf)/ ((double) actdeadline [ k ] )); 
     }
   }
   printf("Maximum infeasibility = %ld \n",maxinf) ;
  printf("Maximum percentage infeasibility = %f \n",max_percent*100.0) ; 
  if (!maxinf) *solved_problems = *solved_problems + 1 ; 
}



long FIND_LATENESS(long m ,
                  long *actdeadline ,
                  long *releases ,
                  long *processing_time ,
                  long *machine_total)
{ 
  long i ; 
  long j ;
  long k ; 
  long lateness ; 


  lateness = -9999 ; 
  for (i=1;i<=m;i++) {
     for (j=1;j<=machine_total[i];j++)  {  
       k = machine_operations[i][j] ; 
       lateness = MAX(lateness,
                      (releases[k]+processing_time[k]-actdeadline[k])) ;
     }
   }
  return(lateness) ;
}


/* 
 *
 */


FIND_CRITICAL_MACHINES(
     long print_output ,
     long m ,
     long *critical ,
     long *machine_sched ,
     long *releases ,
     long *processing_time ,
     long *tails ,
     long *machine_total ,
     long mksp ,
     long *pdc ,
     long *which_machine ,
     long finishing )
{
 long i , j , ii , jj;
 long u ;
 long WEIGHT ; 
 long total_critical_machines ; 
 long bottleneck_index ; 
 long maximum_bottleneck_index ;
 long tmksp ; 
 long critical_machine_arcs ; 
 long actual_critical_machine_arcs ; 

 total_critical_machines  = 0 ; 
 bottleneck_index         = 0 ; 
 maximum_bottleneck_index = 0 ; 
 critical_machine_arcs    = 0 ; 

 for (i=1 ; i <= m ;i++) critical [ i ] = 0 ; 
 u = pdc[ finishing ] ; 
 tmksp = 0 ; 
 while ( u ) {
   tmksp = tmksp + processing_time [ u ] ; 
   if (pdc [ u ]) { 
     if (which_machine [ u ] == which_machine [ pdc [ u ] ] ) {
       critical_machine_arcs++ ; 
       if (critical [ which_machine [ u ] ] == 0) {
         critical [ which_machine [ u ] ] = 1 ; 
         total_critical_machines++ ; 
       }
     }
   }
   u = pdc [ u ] ; 
 }

 /*
 if (print_output)  { 
   printf("Critical machines on a critical path = %ld \n",
          total_critical_machines) ; 
   printf("Critical arcs = %ld \n",critical_machine_arcs) ; 
   printf("Makespan %ld \n",tmksp) ; 
 }
 */

 WEIGHT = 1000 ; 
 total_critical_machines  = 0 ; 
 bottleneck_index         = 0 ; 
 maximum_bottleneck_index = 0 ; 
 actual_critical_machine_arcs    = 0 ; 

 for (i=1;i<=m;i++){
   critical[i] = 0 ; 
   if (machine_sched[i] == 1)  {
     for (j=1;j<machine_total[i];j++) { 
       ii = machine_operations[i][j] ; 
       jj = machine_operations[i][j+1] ;

       if ((releases[ii] + processing_time[ii]+
            processing_time[jj]+tails[jj]) >  mksp)  {
         printf("Error in FIND_CRITICAL_MACHINE() \n") ; 
         exit(1) ; 
       }
       if ((releases[ii] + processing_time[ii]+
            processing_time[jj]+tails[jj]) ==  mksp)  {
         critical[i] = 1 ; 
         actual_critical_machine_arcs++ ; 
       }
     }
   }
   if (critical [ i ] ) { total_critical_machines++ ; }
/*
   bottleneck_index = ((critical [i] ) * 
                       (bottleneck_order [ i ]) *
                       WEIGHT) + bottleneck_index ;
   maximum_bottleneck_index = ((bottleneck_order [ i ]) *WEIGHT) + 
     maximum_bottleneck_index ; 
*/
 }

 my_critical_machines = 
   my_critical_machines + ((double) total_critical_machines) ; 

 total_schedules = total_schedules + 1.0 ; 
 if (actual_critical_machine_arcs > 
     critical_machine_arcs) {
   multiple_critical_machines =  
     multiple_critical_machines + 1.0 ; 
 }

 for (ii=1; ii <=m; ii++) { 
   if (critical [ii ] ) { 
     machine_critical [ ii ] = 
       machine_critical [ ii ] + 1.0 ; 
   }
 }

 /*
 if (print_output) { 
   printf("The schedule has makespan : %ld \n",mksp) ; 
   printf("Number of critical machines = %ld \n",total_critical_machines) ; 
   printf("Percentage of critical machines = %15.2f \n",
          (((double) total_critical_machines) / ((double) m ))*100.0) ; 
   printf("Critical Machine Arcs = %ld \n",critical_machine_arcs) ; 
//   printf("Bottleneck Index : %ld \n",bottleneck_index) ; 
   printf("Maximum bottleneck Index : %ld \n",maximum_bottleneck_index) ; 
//   printf("Average Bottleneck Index = %15.2f \n",
//          (((double) bottleneck_index) / ((double) total_critical_machines)));
 }
 */

}
     

/*
 * 
 */

SORT_KEEP_MAKESPANS(long solution_number ,
                    long *the_order ,
                    long *keep_makespans )
{ long i , j ;
  long *sorted ;
  long point ;
  long biggest ;
  long flag ; 

  flag = aloci(&sorted,100) ;
  for (i=0;i<=solution_number;i++) sorted[i] = 0 ; 
  for (i=1;i<=solution_number;i++)  { /* find the smallest makespan */
     biggest = ((long)  RAND_MAXI) ;  
     for (j=1;j<=solution_number;j++) {
        if ( sorted[j] == 0 ){
          if (keep_makespans[j] < biggest) {
            point= j ; 
            biggest = keep_makespans[j] ; 
              }
          }
      }
   the_order[i] = point ; 
   sorted[point] = 1 ; 
   }
 free((char *) sorted) ; 
}


/*
 *
 */

SEQUENCE_MACHINE_STANDARD(long machi ,
                          long *machine_sched ,
                          long *machine_total ,
                          long *position ,
     long m ,
     long finishing ,
     long *macpred ,
     long *macsucc )
{
  long i , jobi ;

 machine_sched[machi] = 1 ;

 for (i=1;i <= machine_total[machi];i++) { 
   order[i] = machine_operations[machi][i] ;
 }

 for (i=1;i<= machine_total[machi];i++) { 
   machine_operations[machi][i] = order[i] ;
   position[order[i]] = i ;  
 }
 
 for (i=1;i<=machine_total[machi];i++) {
   jobi = machine_operations[machi][i] ;
   if (i>1)  { macpred[jobi] = machine_operations[machi][i-1] ; }
   else  { macpred[jobi] =  0 ;}
     
   if (i<machine_total[machi]){
     macsucc[jobi] = machine_operations[machi][i+1] ; }
   else { macsucc[jobi] =  finishing ;}
   }
}

/*
 *
 */

RETRIEVE_IMPROVED_SOLUTION(
     long *improved_schedule ,
     long *machine_total ,
     long m ,
     long oper )
{ 
  long i , j ; 
  long k ; 

  k = 0 ; 
  for (i=1;i<=m;i++)  {  
      for (j=1;j<=machine_total[i];j++) {
          machine_operations[i][j] =  improved_schedule [ k ] ; 
          k++ ; 
        }
    }
}



/*
 *
 */

SEQUENCE_FIXED_MACHINES(
     long *machine_sched ,
     long *machine_total ,
     long *position ,
     long m ,
     long finishing ,
     long *macpred ,
     long *macsucc ) 
{
  long i ; 
  for (i=1;i<=m;i++)   {
    if (machine_sched[i]) {
      SEQUENCE_MACHINE_STANDARD(i,
                                machine_sched,
                                machine_total,
                                position,
                                m,
                                finishing,
                                macpred,
                                macsucc) ;
    }
  }
}


/*
 *
 */

SEQUENCE_BOTTLENECK(
     long solve_with_deadlines ,
     long m ,
     long bottleneck_machine ,
     long *bmksp ,
     long *machine_sched ,
     long *actrelease ,
     long *releases ,
     long *processing_time ,
     long *tails ,
     long *moddeadline ,
     long *best_order ,
     long *machine_total ,
     long *which_machine , 
     long *position ,
     long oper ,
     long *jobsucc ,
     long *macsucc ,
     long finishing ,
     long *labelled_list ,
     long *jobpred ,
     long *macpred )
{
  long ij ;
  long jobs ; 
  long optimal_makespan ;
  long status ; 
  
  *bmksp = 0 ;
  status = 0 ; 
  
      STORE_SOLVE_PROBLEMS(bottleneck_machine,
                           &jobs,       
                           actrelease,
                           releases,
                           processing_time, 
                           tails,
                           moddeadline,
                           machine_total,
                           which_machine,
                           position,
                           oper,
                           jobsucc,
                           macsucc,
                           finishing,
                           labelled_list,
                           jobpred,
                           macpred,
                           &optimal_makespan,
                           solve_with_deadlines,
                           bmksp,
                           status) ; 

      if  (optimal_makespan > *bmksp) { 
        *bmksp = optimal_makespan  ;
        for (ij=1;ij<=jobs;ij++) { best_order[ij] = order[ij] ; }
      }
}