package LPP_Models;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
import java.util.Scanner;
import java.util.concurrent.TimeUnit;
import ilog.concert.IloException;
import ilog.concert.IloIntVar;
import ilog.concert.IloLinearNumExpr;
import ilog.concert.IloNumVar;
import ilog.cplex.IloCplex;
import java.util.Random;
public class LPP_PARTICULAR_CASE{

static int slots;
static int items;
static double demand[];
static double demand_2[];
static double demand_3[];
static double demand_4[];
static double demand_6[];
static double demand_8[];
static double demand2[];
static int setup_cost;
static int runs;
static double epsilon;
static double waste;
static double num_print;
static double total_demand;
static double cluster_demand;
static double current_demand[];
static double current_demand2[];
static int item_list[];
static int item_list2[];
static int item_list3[];
static int item_list4[];
static double y_i[];
static double y[];
static double rate[];
static double rate2[];
static double toplam_y_i;
static int toplam_y;
static double temp_max;
static int temp_index;
static double quantity_1[];
static double slot_1[];
static double quantity_2[];
static double slot_2[];
static double min;
static double remaining_demand[];
static double remaining_demand2[];
static int assign_slot[][];
static int assign_slot_2[][];
static int assign_slot2[][];
static int assign_slot_3[][];
static int assign_slot_4[][];
static int assign_slot_5[][];
static int assign_slot_6[][];
static int sum_slot;
static double max_quantity;
static double divide[][];
static double item_temp_demand[][];
static double item_temp_demand2[][];
static double item_temp_demand_2[][];
static double item_temp_demand_3[][];
static double temp_dem[][];
static int item_num_slot[][];
static int item_num_slot2[][];
static int item_temp[][];
static int item_temp2[][];
static double temp_dem_2[][];
static int run_order[][];
static int run_order2[][];
static int run_order_2[][];
static int run_order_3[][];
static int run_order_4[][];
static int run_order_5[][];
static int runn_order[][];
static int run_items[];
static int run_items_2[];
static int run_items_3[];
static int run_items_4[];
static int run_items_5[];
static int runn_items[];
static int dizi[];
static int dizi2[];
static int dizi3[];
static int dizi4[];
static int Slots_[];
static int num_it[];
static int num2_it[];
static int num_it_slot;
static int toplam_num_it;
static int toplam_num2_it;
static int kalan_num_it;
static int item_order[];
static int item2_order[][];
static int item3_order[][];
static int item4_order[][];
static int temp_length[];
static int temp2_length[];
static int temp3_length[];
static int Temp_[];
static int Temps_[];
static double length_run[];
static double length_run2[];
static double cluster_length_run[][];
static double cluster_solution[];
static int cluster_assign_slot[][][];
static double total_run_2;
static double Best_Length_run[];
static double Best_Length_run2[];
static double percentage[];
static int run_sayisi[];
static int max_ij [][];
static int max2_ij [][];
static int min2_ij [][];
static double ratio_;
static int min_ij [][];
static int cluster_length;	
static int cluster[];
static int clus_length[][];
static int no_Iter_runs[];
static int cluster_items[][][];
static int runs_2;
static int cluster_length2;	
static int cluster2[];
static int clus_length2[][];
static int no_Iter_runs2[];
static int cluster_items2[][][];
static int runs_3;
static int start_cluster;
static int start_cluster2;
static int iter_cluster[];
static int item_in_list[];
static int item_in_list2[];
static int total_CLUST;
static int tot_CLUST;
static int tot_CLUSTs;
static double B_run[];
static double abs;
static int no_Iter;
static int total_clusters;
static int v_ij[][];
static int v_ij_2[][];
static int S_j[];
static int S_[];
static double B_j[];
static int v_ij_assign_slot[][];
static int v_ij_assign_slot2[][];
static double Solution;
static double demand4[];
static int toplam2_y_i;
static int y2_i[];
static double[][] divide2;
static int tot_cluster2;
static int tot_cluster3;
static int clus_run_items[];
static int z_ij[][];
static int run_num[];
static double total_demand3;
static String[] str= new String[1000];
static int sum_clust;
static double temp;
static int ExraLength;
static int Extraslots;
static double L_U[];
static double L_B[];
static double cost_length;
static double cost_temp;
static double totall_cost;
static double total_cost;
static int mos[];
static int mos_[];
static double item_waste[];
static double obj_value[];
static double Best_Costss;
static double BestSolution;
static int improve2;
static int kacinci_iter;
static int kacinci_iter2;

public static  void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
	Scanner input2 = new Scanner(new File("LPP_PARTICULAR_CASE_INSTANCES.txt"));
			
	 int sss=100000;
	 int sor=0;
	 int sor1=0;
	 int sor2=0;
	 double Sols=0;
	 temp=0;
	 int kss=0;
	 totall_cost=90000000;
	 total_cost=0;
	 improve2=-1;
	double Bestt_Solution=9000000;
	int fls=157;
	for(int a=1; a<fls+1; a++) {
		
		str[a] = input2.nextLine();
	
	}
		
	for(int kls=1; kls<fls+1; kls++) {
			
		Bestt_Solution=9000000;
		
		Scanner input = new Scanner(new File(str[kls]));
		int str2=kls;
		
		
		 PrintWriter printWriter = new PrintWriter ("assign_list.txt");
		
	items = input.nextInt();
	slots = input.nextInt();
	runs = input.nextInt();
	runs=runs;
	int run=runs;
	totall_cost=7000000;
	Best_Costss=7000000;
	int nu=runs;
	int rul=runs;
	int runs_2=0;
	int runs3=runs;
	total_clusters=0;
	total_demand=0;
	Solution=0;
	int ys=0;
	int tr=0;
	int ak=0;
	int reks=690000;
	double big_M=0;

		
	demand=new double [items+1];
	demand_2=new double [items+1];
	demand_3=new double [items+1];
	demand_4=new double [items+1];
	demand_6=new double [items+1];
	demand_8=new double [items+1];
	demand4=new double [items+1];
	demand2=new double [items+1];
	remaining_demand=new double [items+1];
	remaining_demand2=new double [items+1];
	y_i= new double [items+1];
	y= new double [items+1];
	rate= new double [items+1];
	rate2= new double [items+1];
	quantity_1= new double [items+1];
	slot_1= new double [items+1];
	quantity_2= new double [items+1];
	slot_2= new double [items+1];
	assign_slot= new int [items+1][runs+8];
	assign_slot_2= new int [items+1][runs+8];
	assign_slot2= new int [items+1][runs+8];
	assign_slot_3= new int [items+1][runs+8];
	assign_slot_4= new int [items+1][runs+8];
	assign_slot_5= new int [items+1][runs+8];
	assign_slot_6= new int [items+1][reks];
	divide = new double [items+1][runs+8];
	divide2 = new double [items+1][runs+8];
	item_temp_demand = new double [items+1][runs+8];
	item_temp_demand2 = new double [items+1][runs+8];
	item_temp_demand_2 = new double [items+1][runs+8];
	item_temp_demand_3 = new double [items+1][runs+8];
	temp_dem = new double [items+1][runs+8];
	temp_dem_2 = new double [items+1][runs+8];
	item_temp= new int [items+1][runs+8];
	item_temp2= new int [items+1][runs+8];
	item_num_slot= new int [items+1][runs+8];
	item_num_slot2= new int [items+1][runs+8];
	run_order = new int [runs+8][items+1];
	run_order2 = new int [runs+8][items+1];
	runn_order = new int [runs+8][items+1];
	run_order_2 = new int [runs+8][items+1];
	run_order_3 = new int [runs+8][items+1];
	run_order_4 = new int [runs+8][items+1];
	run_order_5 = new int [runs+8][items+1];
	run_items = new int [runs+8];
	run_items_2 = new int [runs+8];
	run_items_3 = new int [runs+8];
	run_items_4 = new int [runs+8];
	run_items_5 = new int [runs+8];
	runn_items = new int [runs+8];
	dizi = new int[items+1];
	dizi2 = new int[items+1];
	dizi3 = new int[items+1];
	dizi4 = new int[items+1];
	item_order = new int[items+1];
	item2_order = new int[items+1][items+1];
	item3_order = new int[items+1][items+1];
	item4_order = new int[items+1][items+1];
	Slots_ = new int [items+1];
	L_U = new double [runs+8];
	L_B = new double [runs+8];
	Temp_ = new int[runs+8];
	Temps_ = new int[runs+8];
	length_run= new double [reks];
	length_run2= new double [reks];
	cluster_length_run= new double [reks][runs+1];
	cluster_solution= new double [reks];
	Best_Length_run= new double [reks];
	percentage= new double [runs+8];
	cluster = new int [items+100];
	cluster2 = new int [items+100];
	current_demand=new double [items+1];
	current_demand2=new double [items+1];
	item_list=new int [items+1];
	item_list2=new int [items+1];
	item_list3=new int [items+1];
	item_list4=new int [items+1];
	run_sayisi=new int [reks];
	no_Iter_runs = new int [reks];
	clus_length = new int [reks][items+1];
	num_it = new int [runs+1];
	num2_it = new int [runs+1];
	no_Iter_runs = new int [reks];
	clus_length2 = new int [reks][items+1];
	item_in_list = new int [items+1];
	item_in_list2 = new int [items+1];
	iter_cluster = new int [items+1];
	max_ij=new int [items+1][runs+1];
	min_ij=new int [items+1][runs+1];
	max2_ij=new int [items+1][runs+1];
	min2_ij=new int [items+1][runs+1];
	v_ij = new int [items+1][reks];
	v_ij_2 = new int [items+1][reks];
	S_j = new int [reks];
	S_ = new int [runs+10];
	B_j = new double [reks];
	B_run = new double [reks];
	v_ij_assign_slot = new int [items+1][reks];
	y2_i= new int[reks];
	clus_run_items= new int[items+1];
	mos = new int[items+1];
	mos_ = new int[items+1];
	item_waste = new double [items+1];
	temp_length = new int[items+1];
	temp2_length = new int[items+1];
	temp3_length = new int[items+1];
	obj_value = new double [300+1];
		
    int tot_cluster4=0;
	 	
	for(int i=1; i<items+1; i++){
		demand[i]=input.nextDouble();
		demand_2[i]=demand[i];
		demand_3[i]=demand[i];
		demand_4[i]=demand[i];
		demand_6[i]=demand[i];
		demand2[i]=demand[i];
		demand_8[i]=demand[i];
		total_demand+=demand[i];
	}
	big_M=4*total_demand;

	rul=runs-1;
	

	int hulls=runs+2;
	improve2=2;
	
	 while(improve2==2) {
		 long StartTime = System.currentTimeMillis();
		  Bestt_Solution=9000000;
			
			
		 rul++;
		 
		 runs=rul;
		 improve2=1;
		 
		 runs3=runs;
		 
		 run=runs;
		 
		 nu=runs;
			
		
		 runs_2=0;
				 runs3=runs;
				total_clusters=0;
				Solution=0;
				 ys=0;
				 tr=0;
				 ak=0;
				
				 sss=100000;
				  sor=0;
				  sor1=0;
				  sor2=0;
				  Sols=0;
				 temp=0;
				  kss=0;
				 totall_cost=90000000;
				 total_cost=0;
		 		 		
		 for(int i=1; i<items+1; i++) {			 
			 mos[i]=0;
		     mos_[i]=0;
			}
	
     cluster_demand=0;
	int cluster_demand2=0;
	double Best_Solution=9000000;
	int best=0;
	double BestSolutions=9000000;
		 		
	for(int i=1; i<items+1; i++){
		for(int j=1; j<runs+1; j++){
			v_ij_2[i][j]=0;
		}
	}

	for(int i=1; i<items+1; i++){
		item_order[i]=0;
		dizi[i]=i;
	}
			
	 double temp_max;
	 int temp_max_index;		
		for(int i = 1; i < items+1; i++)
		{
		temp_max = demand_8[i];
		temp_max_index = i;
		for(int j = i + 1; j <items+1; j++)
		{
		if(demand_8[j] > temp_max){
		
		temp_max = demand_8[j];
		temp_max_index = j;
		item_order[i]=j;
		}
		}
		
		double swap = demand_8[i];
		demand_8[i] = demand_8[temp_max_index];
		demand_8[temp_max_index] = swap;
		
		int swap2 = dizi[i];
		   dizi[i] = dizi[temp_max_index];
		   dizi[temp_max_index] = swap2;
		   
		 int swap3 = dizi[i];
		   dizi[i] = dizi[temp_max_index];
		   dizi[temp_max_index] = swap2;
		}

	double item=items;
	double slot=slots;
		  temp=(int) Math.ceil((item/slot));		  	          
	      for(int j=1; j<runs+1; j++) {
	    	  Temp_[j]=1;
	      }
	
		for(int j=1; j<temp+1; j++) {
			Temp_[j]=0;
			Temps_[j]=10000;
			while(Temps_[j]>=slots*(runs-j+1)) {
				Temp_[j]++;
				Temps_[j]=0;
				for(int i=slots*(j-1)+1; i<items+1; i++) {
					Temps_[j]+= Math.ceil(demand_8[i]/Temp_[j]);
				}
				if(Temps_[j]<slots*(runs-j+1)) {
					Temp_[j]--;
				}
			
			}			 
		}
		
		for(int i=1; i<runs+1; i++){
			item_order[i]=0;
			dizi[i]=i;
		}
		
		int temp_max_2=0;
		 int temp_max_index_2;		
			for(int i = 1; i < runs+1; i++)
			{
			temp_max_2 = S_j[i];
			temp_max_index_2 = i;
			for(int j = i + 1; j <runs+1; j++)
			{
			if(S_j[j] > temp_max_2){
			
			temp_max_2 = S_j[j];
			temp_max_index_2 = j;
			item_order[i]=j;
			}
			}
			
			int swap = S_j[i];
			S_j[i] = S_j[temp_max_index_2];
			S_j[temp_max_index_2] = swap;
			
			int swap2 = dizi[i];
			   dizi[i] = dizi[temp_max_index_2];
			   dizi[temp_max_index_2] = swap2;			   
			}	 			
			  double total_L_B=0;
			  			  																	
	int sln=50000;
	int slnm=0;
	int step=0;
	int heru=0;	
	int slots_=slots;	
	for(int i=1; i<items+1; i++) {
		 current_demand[i]=demand[i];
	 }
					
	Random random2 = new Random();
	
	tot_CLUST=0;
	total_CLUST=0;
	tot_CLUSTs=0;
for(int cs=1; cs<sln+1; cs++) {
	
	int start_cluster=0;
	int start_cluster2=0;
	int iter_cluster_length=0;
	int confirmation=0;
	int sum_items=0;
	int rks=0;
	for(int i=1; i<items+1; i++) {
		iter_cluster[i]=0;
		item_in_list[i]=1;
		cluster[i]=0;
	}
	
	 for(int i=1; i<items+1; i++) {
		 current_demand[i] = demand[i];
	 }	
		 
	 int sls1=0;
	 int sls2=0;
	 int sls3=0;
	 toplam_num_it=0;
	 toplam_num2_it=0;
	 num_it_slot=slots;
	 	 
	 for(int t=1; t<runs+1; t++) {
		 num_it[t]=1;
		 toplam_num2_it+=num_it[t];
	 }
	 int srcd=0;
	 int toplam_num_it3=0;
	 kalan_num_it=0;
	 
	 for(int t=1; t<runs+1; t++) {
		 srcd=0;
		 if(items-toplam_num2_it<=slots) {
			 num_it_slot=items-toplam_num2_it;
		 }
		 num_it[t] = 1+ (int) random2.nextInt(num_it_slot);
		 num2_it[t] = num_it[t];
		 toplam_num_it3=0;
		 for(int rs=1; rs<t+1; rs++) {
			 toplam_num_it3+=num_it[rs]; 
		 }		 
		 kalan_num_it=items-toplam_num_it3;		 
		 if(kalan_num_it>(slots*(runs-t)) && t!=runs) {
			 t--;
			 srcd=1;
		 }
		 if(srcd==0) {
			 sls3+=num_it[t];
			 toplam_num2_it+=num_it[t]-1;
			 if(t==runs) {
				 if(toplam_num2_it<items) {
					 num_it[t]=num_it[t]+(items-toplam_num2_it);
				 }
			 }			 
		 }
		 		 
	 } 
	 	 	 		 
	 int slsk=0;	 
	while(confirmation<1) {
		slsk++;	
	cluster_length2 = (int) 1+random2.nextInt(items-(start_cluster));
	
	if((cluster_length2-9)>0) {
		cluster_length = (int) 10+random2.nextInt(cluster_length2-9);
	}
	
	else {
		cluster_length = items-(start_cluster);
	}
	
	if(cluster_length==items) {
		cluster_length=items-5;;
	}	
	if(cluster_length>items-(start_cluster)) {
		cluster_length=items-(start_cluster);		
	}	
			
	if(cluster_length>slots || cluster_length<1 ) {		
		cluster_length = (int) 1+random2.nextInt(slots);
	}
	
	cluster_length = num_it[slsk];
	
	int list=0;		
	int cnt=0;
	
	for(int i=1; i<items+1; i++) {
		cluster[i]=0;
	}
	int ksk=1;
	int rt=1;
		 
	 for(int i=1; i<items+1; i++){
					dizi2[i]=i;
				}			 
			 for(int i=1; i<items+1; i++) {
				 current_demand2[i] = current_demand[i];
			 }			
				 double temp_max3=0;
				 int temp_max_index3=0;								
						for(int i = 1; i < items+1; i++)
						{
						temp_max3 = current_demand2[i];
						temp_max_index3 = i;
						for(int jn = i + 1; jn <items+1; jn++)
						{
						if(current_demand2[jn] > temp_max3){
						
						temp_max3 = current_demand2[jn];
						temp_max_index3 = jn;
						}
						}
						
						double swaps2 = current_demand2[i];
						current_demand2[i] = current_demand2[temp_max_index3];
						current_demand2[temp_max_index3] = swaps2;
						
						int swap2 = dizi2[i];
						   dizi2[i] = dizi2[temp_max_index3];
						   dizi2[temp_max_index3] = swap2;					   						 
						}
												
						for(int i=1; i<items+1; i++){
								item_list[i]=dizi2[i];
						}						
						int lg=Math.min(cluster_length+2, items-(start_cluster));
						for(int i=1; i<lg+1; i++) {
							 item_list2[i]=item_list[i];
						 }
						cluster_length=Math.min(cluster_length, lg);
						 for(int i=1; i<items+1; i++) {
							 item_list3[i]=0;
						 }
						 int nt=0;
						 int ns=0;
						 for(int i=1; i<cluster_length+1; i++) {
							 nt=0;
							 ns=1+random2.nextInt(lg);
						      for(int ab=1; ab<cluster_length+1; ab++) {							 	
						    	    if(item_list2[ns]==item_list3[ab]) {	
						    	       nt=1;
							       }
						       }
						      if(nt==1) {
						    	  item_list[i]=0;
								  i--;
							  }
						      if(nt==0) {
						    	  item_list3[i]=item_list2[ns];
						    	  item_in_list[item_list2[ns]]=0;
						    	  current_demand[item_list2[ns]]=0;
						    	  start_cluster++;
							  }
						 }						 
						 for(int i=1; i<items+1; i++) {
							 item_list4[i]=0;
						 }						 
						 for(int i=1; i<cluster_length+1; i++) {
							 cluster[i]= item_list3[i];
						 }
						      		
       iter_cluster_length+=cluster_length;
       
   	confirmation=0;
	sum_items=0;
	for(int i=1; i<items+1; i++) {
		if(item_in_list[i]==0) {
			sum_items++;
		}
	}
			
	if(slsk==runs) {
			confirmation=1;
		}
	          
       double temp_max13;
		 int temp_max_index13;		
			for(int i = 1; i < cluster_length+1; i++)
			{
			temp_max13 = cluster[i];
			temp_max_index13 = i;
			for(int j = i + 1; j<cluster_length+1; j++)
			{
			if(cluster[j] < temp_max13){
			
			temp_max13 = cluster[j];
			temp_max_index13 = j;
			}
			}			
			int swap33 = cluster[i];
			cluster[i] = cluster[temp_max_index13];
			cluster[temp_max_index13] = swap33;		
			}

			for(int i=1; i<cluster_length+1; i++){
				cluster_demand+=demand[cluster[i]];
			}
			abs= (double)(cluster_demand/total_demand)*runs3;
			runs_2=(int) Math.ceil(abs);
			cluster_length2=items-cluster_length;
			
			for(int i=1; i<items+1; i++){
				remaining_demand[i]=demand[i];
				y_i[i]=0;
				slot_1[i]=0;
				rate[i]=0;
			}
			 max_quantity=0;
			 for(int i=1; i<cluster_length+1; i++){
					if(remaining_demand[cluster[i]]>0){
					    y_i[cluster[i]]=1;	
					}
				}
			 toplam_y_i=0;
			 for(int i=1; i<cluster_length+1; i++)
				{
					toplam_y_i+=y_i[cluster[i]];
				}
				while(toplam_y_i<=slots){
					
					if(toplam_y_i<slots)
					{
						temp_max=0;
						temp_index=0;
						for(int i=1; i<cluster_length+1; i++)
						{
							rate[cluster[i]]=(int) (remaining_demand[cluster[i]]/y_i[cluster[i]]);
						}
						
						for(int i=1; i<cluster_length+1; i++)
						{
							if(rate[cluster[i]]>=temp_max)
							{
								temp_max=rate[cluster[i]];
								temp_index=cluster[i];
							}
						}
						
						y_i[temp_index]+=1;
						toplam_y_i=0;
						for(int i=1; i<cluster_length+1; i++)
						{
							toplam_y_i+=y_i[cluster[i]];
						}						
					}
					else {						
						for(int i=1; i<cluster_length+1; i++)
						{
							quantity_1[cluster[i]]= Math.ceil(remaining_demand[cluster[i]]/y_i[cluster[i]]);
							slot_1[cluster[i]]=y_i[cluster[i]];						
						}
						toplam_y_i=slots+1;
					}
					}
					toplam_y_i-=1;
					max_quantity=0;					
					for(int i=1; i<cluster_length+1; i++)
					{
						if(quantity_1[cluster[i]]>max_quantity){
							max_quantity=quantity_1[cluster[i]];
						}
					}
					for(int j=1; j<1+1; j++) {
						tot_CLUST++;
						B_run[tot_CLUST]=max_quantity;
						for(int i=1; i<items+1; i++) {
							assign_slot_6[i][tot_CLUST]=(int) y_i[i];
							v_ij_assign_slot[i][tot_CLUST]=(int) y_i[i];
							if(y_i[i]>0.5) {
								v_ij[i][tot_CLUST]=1;								
							}
						}
					}					
	         }					
         } 

         total_CLUST=tot_CLUST;
         total_clusters = total_CLUST;
     	 int sps=0;
     	try {
   		 IloCplex cplex = new IloCplex();
   		 cplex.setParam(IloCplex.DoubleParam.TiLim, 500);
   		  
   			 	 
   			 	 IloNumVar[] standart = new IloNumVar[total_clusters+10];

   					
   		           standart = cplex.boolVarArray(total_clusters+10);
   				 	
   					
   					  IloIntVar[] standart_int = new IloIntVar[total_clusters+10];

   			   			
   			   		 standart_int= cplex.intVarArray(total_clusters+10,0,(int) Double.MAX_VALUE);
   		 	 
   		  IloNumVar[] y = new IloNumVar[total_clusters+10];

   				
   		 	 y= cplex.boolVarArray(total_clusters+10);
   		 	 
           IloLinearNumExpr objective= cplex.linearNumExpr();
           
           for(int j=1; j<total_clusters+1; j++) {
           	objective.addTerm(B_run[j],y[j]);
           	        	  
           }
             
           cplex.addMinimize(objective);
     
           
           for (int j=1; j <total_clusters+1; j++)
   	   	 {
   	   		 IloLinearNumExpr o3= cplex.linearNumExpr();
   	   		 for (int i = 1; i < items+1; i++) {
   	   			 	   	         	
   	   			 o3.addTerm(y[j],v_ij_assign_slot[i][j]);
   	   		 } 
   	   	 }

           
           IloLinearNumExpr fb1= cplex.linearNumExpr();
           for(int j=1; j<total_clusters+1; j++) {
         	  fb1.addTerm(y[j],1);        	  
           }
           cplex.addLe(fb1,runs);
           
           for(int i=1; i<items+1; i++) {
         	  IloLinearNumExpr fb2= cplex.linearNumExpr();
         	  for (int j = 1; j < total_clusters+1; j++) {
         		  fb2.addTerm(B_run[j]*v_ij_assign_slot[i][j],y[j]);
         	  }
         	  cplex.addGe(fb2,demand_3[i]);
           }
           
           for(int i=1; i<items+1; i++) {
           	  IloLinearNumExpr fb3= cplex.linearNumExpr();
           	  for (int j = 1; j < total_clusters+1; j++) {
           		  fb3.addTerm(v_ij[i][j],y[j]);
           	  }
           	  cplex.addEq(fb3,1);           	  
             }       
   		 ys=0;    
   		 Solution=0;
   		 double SPP_Length=0;
   		 
   		 if ( cplex.solve())  {
   			  			 
   		int	 num_print_ilk=0;
   			  for(int j=1; j<total_clusters+1; j++) {
   				  if(cplex.getValue(y[j])>0.9) {
   					  SPP_Length+=B_run[j];  					  
   					 num_print_ilk+=B_run[j]; 					     					  
   				  }
   			  }
   			  
   			  double SPP_Cost = cplex.getObjValue();
   			 double SPP1_COST=SPP_Cost;
   			     				 				
   			  Solution=cplex.getObjValue();
   			  	
   			int	ysc=0;
   			SPP_Length=0;
   			  for(int j=1; j<total_clusters+1; j++) {
   				  
   				  sum_clust++;
   				  if(cplex.getValue(y[j])>0.9) {
   					  ys++;
   					  ysc++;
   					  SPP_Length+=B_run[j];
   					  
   					  for(int i=1; i<items+1; i++) {  						  
   						  assign_slot_5[i][ysc]=v_ij_assign_slot[i][j];  						  
   						  v_ij_2[i][ysc]=1;
   						  S_j[ysc]= (int)(B_run[j]);
   						  v_ij_assign_slot[i][j]=0;
   					  }   					  
   				  }
   			  }   			  
   			  run = ysc;   			  
   			  runs = run;   			  
   			  for(int j=1; j<run+1; j++) {
   				  clus_run_items[j]=0;
   				  for(int i=1; i<items+1; i++) {
   					  if(assign_slot_5[i][j]>0.5) {
   						  v_ij_assign_slot[i][j]=assign_slot_5[i][j];
   						  assign_slot[i][j]=assign_slot_5[i][j];    						  				 
   					      clus_run_items[j]++;
   					  }
   				  }
   			  }
   			  for(int j=1; j<run+1; j++) {
   				  printWriter.println(clus_run_items[j]);
   				  for(int i=1; i<items+1; i++) {
   					  if(assign_slot_5[i][j]>0.5) {   						  
   					  }
   				  }
   			  }   			  			    		  
   		 }
   		 cplex.end() ;
   	}   	   					    				
   					 catch (IloException e) {
   							System.err.println("Concert exception '" + e + "' caught");
   					 }	
   	 double waste_7 = (((Solution*slots)- total_demand)/total_demand);
   	 
   	printWriter.close ();
   					  
	  BestSolution=Solution;
	  BestSolutions=Solution;
	  
		for(int i=1; i<runs+1; i++){
			item_order[i]=0;
			dizi3[i]=i;
		}		
		 temp_max_2=0;
		  temp_max_index_2=0;		
			for(int i = 1; i < runs+1; i++)
			{
			temp_max_2 = S_j[i];
			temp_max_index_2 = i;
			for(int j = i + 1; j <runs+1; j++)
			{
			if(S_j[j] > temp_max_2){
			
			temp_max_2 = S_j[j];
			temp_max_index_2 = j;
			item_order[i]=j;
			}
			}			
			int swap = S_j[i];
			S_j[i] = S_j[temp_max_index_2];
			S_j[temp_max_index_2] = swap;
			
			int swap2 = dizi3[i];
			   dizi3[i] = dizi3[temp_max_index_2];
			   dizi3[temp_max_index_2] = swap2;			   
			}	
			
			 for(int j=1; j<runs+1; j++) {
					L_U[dizi3[j]]=(int) BestSolution/j;
					L_B[dizi3[j]]=Temp_[j];						
				}
			   double mins=1000000;
			  for(int i=1; i<items+1; i++) {
				  if(demand_3[i]/slots<mins) {
					  mins=demand_3[i]/slots;
				  }
			  }
			   total_L_B=0;
						  
			  for(int j=1; j<runs+1; j++) {
					total_L_B+=L_B[j];
				}			  
			  ExraLength=(int) (BestSolution-total_L_B);			  
			  L_U[dizi3[1]] = Math.min(L_B[dizi3[1]]+ExraLength, L_U[dizi3[1]]);			  					  
			  
			  double sum=0;
			  sum=ExraLength;
			  for(int j=2; j<runs+1; j++) {
				  sum=ExraLength;
				  for(int h=j; h>1; h-- ) { 
					  sum=sum+L_B[dizi3[h]];
					  if(Math.floor(sum/(j-h+1))<=L_B[dizi3[h-1]]) {
						  if(L_U[dizi3[j]]>sum/(j-h+1)) {
							  L_U[dizi3[j]]=Math.min(Math.floor(sum/(j-h+1)), L_U[dizi3[j]]);
							  h=0;
						  }
					  }
				  }		  	  		  
			  }
			 
			  for(int j=2; j<runs+1; j++) {
				  if(L_B[dizi3[j-1]]<(L_B[dizi3[j]]+ExraLength)) {
				  L_U[dizi3[j]]= Math.floor((L_B[dizi3[j-1]]+L_B[dizi3[j]]+ExraLength)/2);	
				 }
			  }			  					
					tr=0;			
				for(int i=1; i<items+1; i++) {
					Slots_[i]=(int) Math.ceil(demand_3[i]/L_U[dizi3[1]]);
					 tr+= Slots_[i];
				}				
				Extraslots=(slots*runs)-tr;				
				for(int i=1; i<items+1; i++) {
					for(int j=1; j<runs+1; j++) {
						max2_ij[i][dizi3[j]]=Extraslots+Slots_[i];
						if(max2_ij[i][dizi3[j]]>Math.ceil(demand_6[i]/L_B[dizi3[j]])) {
							max2_ij[i][dizi3[j]]=(int) Math.ceil(demand_6[i]/L_B[dizi3[j]]);
						}
						if(max2_ij[i][dizi3[j]]>slots) {
							max2_ij[i][dizi3[j]]=slots;
						}
					}
				}			  				
				  																
				for(int i=1; i<items+1; i++) {
					for(int j=1; j<runs+1; j++) {
						mos[i]+=max2_ij[i][j];
					}
				}				
			
				 BestSolutions=BestSolution;
				 				 
				 long EndTime1 = System.currentTimeMillis();
				
				int rds=0;
				int full=0;
				int Improve=0;
				int Improves=0;
				int Iteration=0;
				
				kacinci_iter=0;
				kacinci_iter2=0;
				
				while(Improves<1) {
					Improves=1;
					kacinci_iter++;
		
				while(Improve<1) {
					for(int j=1; j<runs+1; j++) {
						for(int i1=1; i1<items+1; i1++) {
							min_ij[i1][j]=0;
							max_ij[i1][j]=0;								
						}
					}
					
					Iteration++;

					Improve=1;
					
					for(int i=1; i<items+1; i++) {
						for(int j=1; j<runs+1; j++) {							
							assign_slot_2[i][j]=assign_slot[i][j];
						}
					}											
						for(int e=1; e<runs; e++) {
										for(int f=e+1; f<runs+1; f++) {										
									for(int i=1; i<items+1; i++) {
										for(int j=1; j<runs+1; j++) {							
											assign_slot[i][j]=assign_slot_2[i][j];
										}
									}
									
									for(int jo=1; jo<runs+1; jo++) {																				
											for(int ik=1; ik<items+1; ik++) {											
												if(jo==e) {
												
												if(assign_slot[ik][e]>0  ) {
													min_ij[ik][e]=assign_slot[ik][e]-5;
													max_ij[ik][e]=assign_slot[ik][e]+5;
													
													min_ij[ik][f]=assign_slot[ik][f]-5;
													max_ij[ik][f]=assign_slot[ik][f]+5;
																						
													
													if(min_ij[ik][e]<0) {
														min_ij[ik][e]=0;
													}
																				
													if(max_ij[ik][e]>max2_ij[ik][e]) {
														max_ij[ik][e]=max2_ij[ik][e];
													}
													

													if(min_ij[ik][f]<0) {
														min_ij[ik][f]=0;
													}
													if(max_ij[ik][f]>max2_ij[ik][f]) {
														max_ij[ik][f]=max2_ij[ik][f];
													}
																																		
												}
												
											}
												
												if( jo==f) {
													
													if( assign_slot[ik][f]>0 ) {
														min_ij[ik][f]=assign_slot[ik][f]-5;
														max_ij[ik][f]=assign_slot[ik][f]+5;
														
														min_ij[ik][e]=assign_slot[ik][e]-5;
														max_ij[ik][e]=assign_slot[ik][e]+5;
														
														if(min_ij[ik][e]<0) {
															min_ij[ik][e]=0;
														}
																					
														if(max_ij[ik][e]>max2_ij[ik][e]) {
															max_ij[ik][e]=max2_ij[ik][e];
														}
														

														if(min_ij[ik][f]<0) {
															min_ij[ik][f]=0;
														}
														if(max_ij[ik][f]>max2_ij[ik][f]) {
															max_ij[ik][f]=max2_ij[ik][f];
														}														
													}													
												}
																					
												if(jo!=e && jo!=f ) {
																									
													min_ij[ik][jo]=assign_slot[ik][jo];
													max_ij[ik][jo]=assign_slot[ik][jo];
													
												}
											}
																		
										
									} 
									
									try {
										 IloCplex cplex = new IloCplex();
										 cplex.setParam(IloCplex.DoubleParam.TiLim, 100);
										 
										 IloNumVar[][][] xijk = new IloNumVar[items+1][runs+1][];
										  for (int i5 = 0; i5 < items+1; i5++)
										     {
											  for (int j = 0; j < runs+1; j++)
											     {
												   xijk[i5][j] = cplex.boolVarArray(slots+1);
										     }
										     }
										  IloIntVar[][][] qijk = new IloIntVar[items+1][runs+1][];
										  
										  for (int i5 = 0; i5 < items+1; i5++)
										     {
											  for (int j = 0; j < runs+1; j++)
											     {
												   qijk[i5][j] = cplex.intVarArray(slots+1,0,(int) Double.MAX_VALUE);
										     }
										     }
										  IloNumVar[][] y_ij = new IloNumVar[items+1][];
										  
										  for (int i5 = 0; i5 < items+1; i5++)
										     {
											  
												   y_ij[i5] = cplex.boolVarArray(runs+1);
										     }
										  IloIntVar[] Lj = new IloIntVar[runs+1];

												
											 	 Lj= cplex.intVarArray(runs+1,0,(int) Double.MAX_VALUE);;
										    
									
									  IloLinearNumExpr objective= cplex.linearNumExpr();
									  						
										 for (int j=1; j < runs+1; j++)
										 {  
												 objective.addTerm(Lj[j], 1);											
										     }

										 cplex.addMinimize(objective);
										 																				 
										 for (int i5=1; i5 < items+1; i5++)
										 {
											 IloLinearNumExpr o= cplex.linearNumExpr();
											 for (int j = 1; j < runs+1; j++) {
												 for (int k = min_ij[i5][j]; k<max_ij[i5][j]+1; k++) {
										         
												 o.addTerm(qijk[i5][j][k], 1);						 						      
										     }
											 
											 } 
										 cplex.addGe(o,demand_4[i5]);	
										 }
										 
										 for (int j=1; j <runs+1; j++)
										 {
											 IloLinearNumExpr o3= cplex.linearNumExpr();
											 for (int i5 = 1; i5 < items+1; i5++) {
												 for (int k = min_ij[i5][j]; k<max_ij[i5][j]+1; k++) {
										         
												 o3.addTerm(xijk[i5][j][k], k);						 						      
										     }
											 
											 } 
										 cplex.addLe(o3, slots);	
										 }
										 		 		 		 
										 for (int i5=1; i5 < items+1; i5++)
										 {
											 
											 for (int j=1; j < runs+1; j++)
											 {
												 
												 for (int k=min_ij[i5][j]; k <max_ij[i5][j]+1; k++)
												 {
													 cplex.addLe(qijk[i5][j][k], cplex.prod(k, Lj[j]));
												 }
											 }
										 }
										 
																		 
										 for (int i5=1; i5 < items+1; i5++)
										 {
											 
											 for (int j=1; j < runs+1; j++)
											 {
												 
												 for (int k=min_ij[i5][j]; k <max_ij[i5][j]+1; k++)
												 {
													 cplex.addLe(qijk[i5][j][k], cplex.prod(big_M, xijk[i5][j][k]));
												 }
											 }
										 }
										 for (int i5=1; i5 < items+1; i5++)
										 {
											 for (int j=1; j < runs+1; j++)
											 {
												 IloLinearNumExpr o34= cplex.linearNumExpr();
												 
												 for (int k=min_ij[i5][j]; k < max_ij[i5][j]+1; k++)
												 {
													 o34.addTerm(xijk[i5][j][k], 1);	 
												 }
												 
												 cplex.addEq(o34,1);	
												  
											 }
										 }
										 																									 
										 for (int j=1; j < runs+1; j++)
										 {
											 IloLinearNumExpr vk= cplex.linearNumExpr();
											 for (int i5=1; i5 < items+1; i5++)
											 {
												 for (int k=1; k < max_ij[i5][j]+1; k++)
												 {
												 vk.addTerm(qijk[i5][j][k], 1);	  
												 }				 
											 }
											 cplex.addLe(vk,cplex.prod(slots, Lj[j]));	
										 }
										 
										 for (int j=1; j < runs+1; j++)
									   	 {
											 cplex.addLe(Lj[j], L_U[dizi3[1]]);											 
										     cplex.addGe(Lj[j],1);
											 
									   	 }
										 										 										 
										 for(int i=1; i<items+1; i++) {
											 IloLinearNumExpr vk_3= cplex.linearNumExpr();
											 for(int j=1; j<runs+1; j++) {
												 vk_3.addTerm(y_ij[i][j],1);
											 }
												 cplex.addEq(vk_3,1);
										 }
										 
										 for (int i5=1; i5 < items+1; i5++)
										 {
											 for (int j=1; j < runs+1; j++)
											 {
												 for (int k=min_ij[i5][j]; k < max_ij[i5][j]+1; k++)
												 {
													 cplex.addLe(qijk[i5][j][k],cplex.prod(big_M,y_ij[i5][j]));
												 }
											 }
											 
										 }
															 										 
										  if ( cplex.solve())  {
											  																						 
												 Sols=cplex.getObjValue();
												  double waste_3=(((Sols*slots)-total_demand)/Sols*slots);
													
												 for (int j=1; j < runs+1; j++)
												 {													 
													 for (int i1=1; i1 < items+1; i1++)
													 {														 
														 for (int k=min_ij[i1][j]; k <max_ij[i1][j]+1; k++)
														 {						
															 if(cplex.getValue(xijk[i1][j][k])>0.9) {
															 assign_slot[i1][j]=k;
															 }																									 
														 }
													 }
												 }
												 									
												 if(cplex.getObjValue()<BestSolutions-0.5) {
																		BestSolutions=cplex.getObjValue();
																	full++;
																	Improve=0;
																		for(int k=1; k<items+1; k++) {
																			for(int j=1; j<runs+1; j++) {
																				item_temp_demand_3[k][j]=item_temp_demand[k][j];
																				assign_slot_3[k][j]=assign_slot[k][j];															
																			}
																		}																		
																		for(int j=1; j<runs+1; j++) {
																			S_[j]=(int) cplex.getValue(Lj[j]);
																		}
												 }
												 
												 for(int k=1; k<items+1; k++) {
														for(int j=1; j<runs+1; j++) {
															item_temp_demand[k][j]=item_temp_demand_2[k][j];
															assign_slot[k][j]=assign_slot_2[k][j];
															run_order[j][k]=run_order_2[j][k];
															run_items[j]=run_items_2[j];				
														}
													}			
												 num_print=0;
												 for (int j=1; j < runs+1; j++)
												 {
													 num_print+=cplex.getValue(Lj[j]);
													 
												 }
													 
													 waste=((num_print*slots)-total_demand)/total_demand;																				 					  						  
										 
										  }
										  cplex.end() ;
									}
																						 												
													 catch (IloException g) {
															System.err.println("Concert exception '" + e + "' caught");
													 }	
																																					
								}  
																
							}  
																							 						
					if(full>0) {
						for(int k=1; k<items+1; k++) {
							for(int j=1; j<runs+1; j++) {								
								assign_slot[k][j]=assign_slot_3[k][j];				
							}
						}	
						}		
					
							} 
				
				
				if(Improve==1 ) {
																				
					for(int i=1; i<items+1; i++) {	
						for(int j=1; j<runs+1; j++) {
							item_waste[i]+=(S_[j]*assign_slot[i][j]);
						}
						item_waste[i]=item_waste[i]-demand_4[i];
					}
						
					for(int k=1; k<items+1; k++) {
						for(int j=1; j<runs+1; j++) {								
							assign_slot_2[k][j]=assign_slot[k][j];				
						}
					}	
					int hcn=0;
					int full1=0;					
					Random random = new Random();
					int num1=0;
					while (hcn<100) {
						hcn++;						
						for(int k=1; k<items+1; k++) {
							for(int j=1; j<runs+1; j++) {								
								assign_slot[k][j]=assign_slot_2[k][j];				
							}
						}												 						 
							for(int i=1; i<items+1; i++) {
								item_in_list2[i]=0;
								cluster2[i]=0;
							}							
							if(items<=10) {
								 num1=5+random.nextInt(5);
								 if(num1>=0.6*items) {
									 num1=4+random.nextInt(4);
								 }
							}
							
							if(items<=15  && items>10) {
								 num1=5+random.nextInt(5);
							}
							
							if(items<=20  && items>15) {
								 num1=5+random.nextInt(5);
							}
							
							if(items<=25  && items>20) {
								 num1=5+random.nextInt(5);
							}
							
							if(items<=100  && items>25) {
								 num1=5+random.nextInt(5);
							}
															
							int	 list=0;
								for(int i=1; i<items+1; i++) {
									cluster2[i]=0;
								}
								int ksks=1;
								while(list<num1) {
										int fbs=(int) 1+random.nextInt(items);
										ksks=1;
										for(int as=1; as<=list+1; as++) {
											if(fbs==cluster2[as]) {
												ksks=0;
											}	
										}
										if(ksks==1) {
											
											list++;
											cluster2[list]=fbs;
											item_in_list2[fbs]=1;
										}
										else {
											
										}												
								}
																																			 
								 for(int i=1; i<items+1; i++) {
									 if(item_in_list2[i]==1) {
										 for(int j=1; j<runs+1; j++) {
											 min_ij[i][j]=assign_slot[i][j]-5;
											 max_ij[i][j]=assign_slot[i][j]+5;
											 
											 if(min_ij[i][j]<0) {
													min_ij[i][j]=0;
												}
												if(max_ij[i][j]>max2_ij[i][j]) {
													max_ij[i][j]=max2_ij[i][j];
												}
										 }
									 }
									 else {
										 for(int j=1; j<runs+1; j++) {
											 min_ij[i][j]=assign_slot[i][j];
											 max_ij[i][j]=assign_slot[i][j];
										 }
									 }
								 }								 
								 												
						try {
							 IloCplex cplex = new IloCplex();
							 cplex.setParam(IloCplex.DoubleParam.TiLim, 20);
							 
							 IloNumVar[][][] xijk = new IloNumVar[items+1][runs+1][];
							  for (int i5 = 0; i5 < items+1; i5++)
							     {
								  for (int j = 0; j < runs+1; j++)
								     {
									   xijk[i5][j] = cplex.boolVarArray(slots+1);
							     }
							     }
							  IloIntVar[][][] qijk = new IloIntVar[items+1][runs+1][];
							  
							  for (int i5 = 0; i5 < items+1; i5++)
							     {
								  for (int j = 0; j < runs+1; j++)
								     {
									   qijk[i5][j] = cplex.intVarArray(slots+1,0,(int) Double.MAX_VALUE);
							     }
							     }
							  IloNumVar[][] y_ij = new IloNumVar[items+1][];
							  
							  for (int i5 = 0; i5 < items+1; i5++)
							     {
								  
									   y_ij[i5] = cplex.boolVarArray(runs+1);
							     }
							  IloIntVar[] Lj = new IloIntVar[runs+1];

									
								 	 Lj= cplex.intVarArray(runs+1,0,(int) Double.MAX_VALUE);;
							    
						
						  IloLinearNumExpr objective= cplex.linearNumExpr();
						  						
							 for (int j=1; j < runs+1; j++)
							 {  
									 objective.addTerm(Lj[j], 1);
									 			 
							     }							 
							 cplex.addMinimize(objective);
							 														 
							 for (int i5=1; i5 < items+1; i5++)
							 {
								 IloLinearNumExpr o= cplex.linearNumExpr();
								 for (int j = 1; j < runs+1; j++) {
									 for (int k = min_ij[i5][j]; k<max_ij[i5][j]+1; k++) {
							         
									 o.addTerm(qijk[i5][j][k], 1);						 						      
							     }
								 
								 } 
							 cplex.addGe(o,demand_4[i5]);	
							 }
							 
							 for (int j=1; j <runs+1; j++)
							 {
								 IloLinearNumExpr o3= cplex.linearNumExpr();
								 for (int i5 = 1; i5 < items+1; i5++) {
									 for (int k = min_ij[i5][j]; k<max_ij[i5][j]+1; k++) {
							         
									 o3.addTerm(xijk[i5][j][k], k);						 						      
							     }
								 
								 } 
							 cplex.addLe(o3, slots);	
							 }
							 		 		 		 
							 for (int i5=1; i5 < items+1; i5++)
							 {
								 
								 for (int j=1; j < runs+1; j++)
								 {
									 
									 for (int k=min_ij[i5][j]; k <max_ij[i5][j]+1; k++)
									 {
										 cplex.addLe(qijk[i5][j][k], cplex.prod(k, Lj[j]));
									 }
								 }
							 }
							 							 
							 for (int i5=1; i5 < items+1; i5++)
							 {
								 
								 for (int j=1; j < runs+1; j++)
								 {									 
									 for (int k=min_ij[i5][j]; k <max_ij[i5][j]+1; k++)
									 {
										 cplex.addLe(qijk[i5][j][k], cplex.prod(big_M, xijk[i5][j][k]));
									 }
								 }
							 }
							 for (int i5=1; i5 < items+1; i5++)
							 {
								 for (int j=1; j < runs+1; j++)
								 {
									 IloLinearNumExpr o34= cplex.linearNumExpr();
									 
									 for (int k=min_ij[i5][j]; k < max_ij[i5][j]+1; k++)
									 {
										 o34.addTerm(xijk[i5][j][k], 1);	 
									 }
									 
									 cplex.addEq(o34,1);	
									  
								 }
							 }
							 																			 
							 for (int j=1; j < runs+1; j++)
							 {
								 IloLinearNumExpr vk= cplex.linearNumExpr();
								 for (int i5=1; i5 < items+1; i5++)
								 {
									 for (int k=1; k < max_ij[i5][j]+1; k++)
									 {
									 vk.addTerm(qijk[i5][j][k], 1);	  
									 }				 
								 }
								 cplex.addLe(vk,cplex.prod(slots, Lj[j]));	
							 }
							 
							 for (int j=1; j < runs+1; j++)
						   	 {
								 cplex.addLe(Lj[j], L_U[dizi3[1]]);
						   		 cplex.addGe(Lj[j], 1);
						   	 }
							 						 
							 for(int i=1; i<items+1; i++) {
								 IloLinearNumExpr vk_3= cplex.linearNumExpr();
								 for(int j=1; j<runs+1; j++) {
									 vk_3.addTerm(y_ij[i][j],1);
								 }
									 cplex.addEq(vk_3,1);
							 }
							 
							 for (int i5=1; i5 < items+1; i5++)
							 {
								 for (int j=1; j < runs+1; j++)
								 {
									 for (int k=min_ij[i5][j]; k < max_ij[i5][j]+1; k++)
									 {
										 cplex.addLe(qijk[i5][j][k],cplex.prod(big_M,y_ij[i5][j]));
									 }
								 }								 
							 }							 													 	 
							  if ( cplex.solve())  {
								  									
									 
									 Sols=cplex.getObjValue();
									  double waste_3=(((Sols*slots)-total_demand)/Sols*slots);
										
									 for (int j=1; j < runs+1; j++)
									 {										 
										 for (int i1=1; i1 < items+1; i1++)
										 {											 
											 for (int k=min_ij[i1][j]; k <max_ij[i1][j]+1; k++)
											 {
												 if(cplex.getValue(xijk[i1][j][k])>0.9) {
												 assign_slot[i1][j]=k;
												 }												 
											 }
										 }
									 }

									 if(cplex.getObjValue()<BestSolutions-0.5) {
															BestSolutions=cplex.getObjValue();
														full1++;
														Improves=0;
															for(int k=1; k<items+1; k++) {
																for(int j=1; j<runs+1; j++) {
																	item_temp_demand_3[k][j]=item_temp_demand[k][j];
																	assign_slot_3[k][j]=assign_slot[k][j];														
																}
															}	
															
															for(int j=1; j<runs+1; j++) {
																S_[j]=(int) cplex.getValue(Lj[j]);
															}
									 }
									 
									 for(int k=1; k<items+1; k++) {
											for(int j=1; j<runs+1; j++) {
												item_temp_demand[k][j]=item_temp_demand_2[k][j];
												assign_slot[k][j]=assign_slot_2[k][j];
												run_order[j][k]=run_order_2[j][k];
												run_items[j]=run_items_2[j];				
											}
										}			
									 num_print=0;
									 for (int j=1; j < runs+1; j++)
									 {
										 num_print+=cplex.getValue(Lj[j]);
										 
									 }
										 
										 waste=((num_print*slots)-total_demand)/total_demand;																	 					  						  
							 
							  }
							  cplex.end() ;
						}
															
										 catch (IloException eg) {
												System.err.println("Concert exception '" + eg + "' caught");
										 }	
					}
					
					if(full1>0) {
						for(int k=1; k<items+1; k++) {
							for(int j=1; j<runs+1; j++) {								
								assign_slot[k][j]=assign_slot_3[k][j];				
							}
						}	
						}					
				}
				
				Bestt_Solution=BestSolutions;
								 				  												
			}  
					
				Bestt_Solution=BestSolutions;
				
				Best_Solution=BestSolutions;
						
				long EndTime2 = System.currentTimeMillis();
				
				long output2 = EndTime2 - EndTime1;								
		
	 }  
	}  

}

}