// Copyright (c) 2015 Carnegie Mellon University.
// All Rights Reserved.
// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following acknowledgments and disclaimers.
// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following acknowledgments and disclaimers in the documentation and/or other materials provided with the distribution.
// 3. Products derived from this software may not include “Carnegie Mellon University,” "SEI” and/or “Software Engineering Institute" in the name of such derived product, nor shall “Carnegie Mellon University,” "SEI” and/or “Software Engineering Institute" be used to endorse or promote products derived from this software without prior written permission. For written permission, please contact permission@sei.cmu.edu.
// ACKNOWLEDGMENTS AND DISCLAIMERS:
// Copyright 2015 Carnegie Mellon University
// This material is based upon work funded and supported by the Department of Defense under Contract No. FA8721-05-C-0003 with Carnegie Mellon University for the operation of the Software Engineering Institute, a federally funded research and development center.
// Any opinions, findings and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the United States Department of Defense.
// NO WARRANTY. THIS CARNEGIE MELLON UNIVERSITY AND SOFTWARE ENGINEERING INSTITUTE MATERIAL IS FURNISHED ON AN “AS-IS” BASIS. CARNEGIE MELLON UNIVERSITY MAKES NO WARRANTIES OF ANY KIND, EITHER EXPRESSED OR IMPLIED, AS TO ANY MATTER INCLUDING, BUT NOT LIMITED TO, WARRANTY OF FITNESS FOR PURPOSE OR MERCHANTABILITY, EXCLUSIVITY, OR RESULTS OBTAINED FROM USE OF THE MATERIAL. CARNEGIE MELLON UNIVERSITY DOES NOT MAKE ANY WARRANTY OF ANY KIND WITH RESPECT TO FREEDOM FROM PATENT, TRADEMARK, OR COPYRIGHT INFRINGEMENT.
// This material has been approved for public release and unlimited distribution.
// DM-0002626
//
// What is this?
//   It is a program that performs schedulability analysis and
//   memory mapping configuration for parallel real-time tasks
//   scheduled with global Earliest-Deadline-First.
//
// How do I install it?
//   First, install Gurobi 6.0. It is free for academic users.
//   You can download it from www.gurobi.com
//   Then compile it as follows:
//     gcc -m64 -g -o parmemconfig parmemconfig.c -I/home/bjorn/gurobi/gurobi600/linux64/include -O3 -lm
//   Then create a file system.txt which describes the taskset and computer
//   platform that you want to analyze.
//   You can run it with a single system as input as follows:
//     parmemconfig -i system.txt -o result_from_analysis.txt
//   If the system is deemed schedulable then the file result_from_analysis
//   contains the memory mapping; otherwise the file result_from_analysis is deleted.
//  
// What is the file format of the input file (e.g. system.txt) ?
//   You can learn about the format of the input file by studying the function
//   readsystemfromfile( FILE* f) in this source code file.
//   The format is as follows:
//
//    3 
//    3600.000000 
// 
//    20 
//    4 
//    1.000000 
//    32
//    16
//    0.250000
//    524288
//    1500000000.000000
//    4.000000
//    20.000000
//    7.000000
//    8.000000
//    5.000000
//    9.000000
//    9.000000
//    9.000000
//    10.000000
//    12
// 
//    3
// 
//    0.100000 0.100000 3
//    1 0.001000 17
//    100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 
//    4 0.030000 17
//    1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 
//    1 0.001000 17
//    100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 
// 
//    0.010000 0.010000 1
//    1 0.002000 17
//    100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 
// 
//    0.100000 0.044000 3
//    1 0.002000 17
//    100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 
//    2 0.006000 17
//    100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 
//    1 0.002000 17
//    100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 
// 
//    12
//    1 1 1 0 1 2 1 0
//    1 1 1 1 1 2 2 0
//    1 1 1 2 1 2 3 0
//    1 1 1 3 1 2 4 0
//    1 3 1 0 1 2 1 1
//    1 3 1 1 1 2 2 1
//    1 3 1 2 1 2 3 1
//    1 3 1 3 1 2 4 1
//    3 1 1 0 3 2 1 0
//    3 1 1 1 3 2 2 0
//    3 3 1 0 3 2 1 1
//    3 3 1 1 3 2 2 1
//    970
//
// What is the file format of the output file (e.g. result_from_analysis.txt) ?
//   The format is as follows:
//     1 2 1 16 25 13
//     ...
//   The first line means that for task 1, its 2nd stage, its 1st segment, its
//     page 16 should be mapped to a frame oc cache color 25 and bank color 13.
//
// How do I generate a default system?
//   Do the following:
//     parmemconfig -g
//
// How do I test many systems (as a form of self-check)?
//   You can run it in meta mode (generates many systems and analyzes/configures all of them):
//     parmemconfig -m
//
// How much memory does this program require?
//   The program is memory hungry. We recommend that you have at last 16 Gigabyte of main memory to run the analysis/configuration.
//   If you run the meta mode (with switch -m) then you need this much memory to run the analysis/configuration.
//   You can run with the mode -m2 and then it runs a smaller system and this consumes less memory.
//
// How do I know if a solution is found?
//   If a solution is found then a file is written with the memory mapping. By default, the name of this file is result_from_analysis.txt.
//   This file contains rows with 6 integers in each row.
//   An example of what this file may look like is as follows:
//     1 1 1 0 5 13
//     1 1 1 1 19 1
//     1 1 1 2 21 15
//     1 1 1 3 12 14
//     1 2 1 0 5 13
//     1 2 1 1 5 13
//     ...
//   The numbers on a line should be read as follows:
//     the first column is task index (i); the second column is stage index (j); the third column is the segment index (g);
//     the fourth column is the page index (p); the fifth column is the cache color; the sixth column is the bank color.
//     Each line specifies that a certain page of a certain segment of a certain stage of a certain task should be mapped
//     to a cell (cache color and bank color).

#define CALLGUROBITHROUGHAPI 0

#define COMPILEMSVS 0

#define COMPILEWIN32 0

#define COMPILEOSX 0

#if COMPILEMSVS

#else
  #include "gurobi_c.h"  
#endif

// We add these in order to do file I/O like in UNIX. And ceil(..)
#include <stdlib.h>
#include <stdio.h>

#include <time.h> // we add this in order to call the function time( ..)

#if COMPILEMSVS
  #include <io.h>
#endif
#include <fcntl.h>

#if COMPILEMSVS
  #include <process.h>
#endif

#include <math.h>

#if COMPILEWIN32
  #include <windows.h>
#endif

#include <string.h>   //  this is needed for strcmp

#if COMPILEMSVS
  #include <direct.h>
#else
  #include <unistd.h>
#endif

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

#if COMPILEWIN32
  #include <pthread.h>
#endif

#define MAXNVARS 10000000 // if this is set to 25000000 then we get swapping one some examples
#define MAXVARIABLESTRINGLENGTH 25

struct memoryaccessesofstagestruct {
	int npages;
	int* MA;
};

struct structoftask {
  double T;
  double D;
  int nstages;
  int* nsegments_of_stage;
  double* exec_of_stage;
  struct memoryaccessesofstagestruct* memoryaccessesdescription;
};

int method = 3;

int K;

// the computer platform
int nprocessors;    // this is the number of processors
double s; // this is the speed of processors

// the taskset
int ntasks;    // this is the number of tasks
struct structoftask* tasks = NULL;

int H; // number of cache colors // first cache set is cache set 0
int B; // number of banks        // first bank is bank 0

// double HWSHARE;
int MEMCAP; // this is the memory capacity of the entire computer system in terms of the number of frames
int CAP; // this is the memory capacity of a cell

double Linterpre;
double Linteract;
double Linterrw;
double Lconf;
double Lconhits1;
double Linter;

struct framesharingspecification {
  int iprime;
  int jprime;
  int gprime;
  int pprime;
  int iprimeprime;
  int jprimeprime;
  int gprimeprime;
  int pprimeprime;
};

double MBCF;

int nelements_in_sharedframes;
struct framesharingspecification* sharedframes = NULL;

int Nre;
int INO; // this is the total number of pages accessed during initialization

// derived parameters
double P; // this is the lcm of Tis.

double SCALINGFACTORNACCESSES = 8388608.0;

double GUROBITIMEOUTPARAMETER = 3600.0;

char inputfilename[2000] = "system.txt";
char outputfilename[2000] = "result_from_analysis.txt";

int meta_mode = 0;
int metatwo_mode = 0;

int counterforILPsolver;

int myGRB_INT_PAR_MIPFOCUS  = 1;
int myGRB_INT_PAR_AGGREGATE = 0;
double myGRB_DBL_PAR_FEASIBILITYTOL  = 0.000000001;
double myGRB_DBL_PAR_INTFEASTOL = 0.000000001;
double myGRB_DBL_PAR_MARKOWITZTOL  = 0.5;
int myGRB_INT_PAR_QUAD = 1;
int myGRB_INT_PAR_NUMERICFOCUS  = 3;
double myGRB_DBL_PAR_HEURISTICS = 0.5;
double myGRB_DBL_PAR_FEASRELAXBIGM = 1000000000000*100;

int gurobipathisset = 0;
char gurobipath[200];
int generate_one_system_mode = 0;

#if CALLGUROBITHROUGHAPI

#else
  FILE* gurobithroughcommandlinelpfile;
  char gurobithroughcommandlinelpfilename[200];
  FILE* gurobithroughcommandlinepyfile;
  char gurobithroughcommandlinepyfilename[200];
  char commandstringwithscript[200];
#endif

//clock_gettime is not implemented on OSX, so use this one
#ifdef __MACH__
#include <sys/time.h>
int clock_gettime(int clk_id, struct timespec* t) {
    struct timeval now;
    int rv = gettimeofday(&now, NULL);
    if (rv) return rv;
    t->tv_sec  = now.tv_sec;
    t->tv_nsec = now.tv_usec * 1000;
    return 0;
}
#endif

// Sleep function that switches on which platform we're running on
void my_sleep(int duration)
{
  #if COMPILEWIN32
    Sleep(duration);
  #else
    sleep(duration);
  #endif

  return;
}

void addcharactertoendofstringifmissing(char* s, char c)
{
  int len;
  len = strlen(s);
  if (s[len-1]!=c) {
    s[len] = c;
    s[len+1] = '\0';
  }
}

#if CALLGUROBITHROUGHAPI

#else

void create_Gurobi_command_line_for_executing_script()
{
#if COMPILEMSVS
   if (gurobipathisset) {
     addcharactertoendofstringifmissing(gurobipath,'\\');
     sprintf( commandstringwithscript, "%sgurobi.bat %s", gurobipath, gurobithroughcommandlinepyfilename);
   } else {
     sprintf( commandstringwithscript, "gurobi.bat %s", gurobithroughcommandlinepyfilename);
   }
#else
  #if COMPILEWIN32
   if (gurobipathisset) {
     addcharactertoendofstringifmissing(gurobipath,'\\');
     sprintf( commandstringwithscript, "%sgurobi.bat %s", gurobipath, gurobithroughcommandlinepyfilename);
   } else {
     sprintf( commandstringwithscript, "gurobi.bat %s", gurobithroughcommandlinepyfilename);
   }
   #else
   if (gurobipathisset) {
     addcharactertoendofstringifmissing(gurobipath,'/');
     sprintf( commandstringwithscript, "%sgurobi.sh %s", gurobipath, gurobithroughcommandlinepyfilename);
   } else {
     sprintf( commandstringwithscript, "gurobi.sh %s", gurobithroughcommandlinepyfilename);
   }
   #endif
#endif
}

#endif

int minint2( int t1, int t2)
{
	if (t1<t2) {
	  return t1;
	} else {
	  return t2;	
	}
}
int maxint2( int t1, int t2)
{
	if (t1>t2) {
	  return t1;
	} else {
	  return t2;	
	}
}

double mindouble2( double t1, double t2)
{
	if (t1<t2) {
	  return t1;
	} else {
	  return t2;	
	}
}

double maxdouble2( double t1, double t2)
{
	if (t1>t2) {
	  return t1;
	} else {
	  return t2;	
	}
}
double maxdouble3( double t1, double t2, double t3)
{
	double temp;
	temp = maxdouble2(t1,t2);
    return maxdouble2( temp, t3 );
}
double maxdouble4( double t1, double t2, double t3, double t4)
{
	double temp;
	temp = maxdouble3(t1,t2,t3);
    return maxdouble2( temp, t4 );
}
double maxdouble5( double t1, double t2, double t3, double t4, double t5)
{
	double temp;
	temp = maxdouble4(t1,t2,t3,t4);
    return maxdouble2( temp, t5 );
}

int divandceil( int n1, int n2)
{
  if (n1%n2==0) {
	  return (n1/n2);
  } else {
	  return (n1/n2)+1;
  }
}
int divandfloor( int n1, int n2)
{
  return (n1/n2);
}

double trrd = 4;  // measured in cycles
double tfaw = 20; // measured in cycles
double wl = 7;    // measured in cycles
double bl = 8;    // measured in columns
double twtr = 5;  // measured in cycles
double cl = 9;    // measured in cycles
double trp = 9;   // measured in cycles
double trcd = 9;  // measured in cycles
double twr = 10;  // measured in cycles

void setmemoryparameters()
{
  Linterpre   = 1;
  Linteract   = maxdouble2(trrd,tfaw-3*trrd);
  Linterrw    = maxdouble2(wl+bl/2+twtr,cl+bl/2+2-wl);
  Lconf       = (trp+trcd)+maxdouble2(cl+bl/2+2,wl+bl/2+maxdouble2(twtr,twr));
  Lconhits1   = (wl+bl/2+twtr + twr - twtr);
  Linter = Linterpre + Linteract + Linterrw;
}

double getLconhitNre()
{
  double temp;
  temp = divandceil(Nre,2)*(wl+bl/2+twtr) + divandfloor(Nre,2)*cl + (twr-twtr);
  return temp;
}

void printmemoryparameters()
{
  printf("Linterpre = %15.10lf\n",Linterpre);
  printf("Linteract = %15.10lf\n",Linteract);
  printf("Linterrw = %15.10lf\n",Linterrw);
  printf("Lconf = %15.10lf\n",Lconf);
  printf("Lconhits1 = %15.10lf\n",Lconhits1);
  printf("Linter = %15.10lf\n",Linter);
}

void makesharedframesempty()
{
    nelements_in_sharedframes = 0;
}

void allocatemakesharedframesempty(int nelements)
{
    nelements_in_sharedframes = 0;
    sharedframes =  (struct framesharingspecification*)  malloc(sizeof(struct framesharingspecification)*nelements);
    if (sharedframes==NULL) { printf("malloc failure in allocatemakesharedframesempty\n"); exit( -1); }
}
void freemakesharedframes()
{
    if (sharedframes!=NULL) {
      free( sharedframes);
      sharedframes = NULL;
    }
}

void addelementtosharedframes( int iprime, int jprime, int gprime, int pprime, int iprimeprime, int jprimeprime, int gprimeprime, int pprimeprime)
{
	sharedframes[nelements_in_sharedframes].iprime      = iprime;
	sharedframes[nelements_in_sharedframes].jprime      = jprime;
	sharedframes[nelements_in_sharedframes].gprime      = gprime;
	sharedframes[nelements_in_sharedframes].pprime      = pprime;
	sharedframes[nelements_in_sharedframes].iprimeprime = iprimeprime;
	sharedframes[nelements_in_sharedframes].jprimeprime = jprimeprime;
	sharedframes[nelements_in_sharedframes].gprimeprime = gprimeprime;
	sharedframes[nelements_in_sharedframes].pprimeprime = pprimeprime;
    nelements_in_sharedframes = nelements_in_sharedframes + 1;
}

int is_in_sharedframes(int iprime, int jprime, int gprime, int pprime, int iprimeprime, int jprimeprime, int gprimeprime, int pprimeprime)
{
  int found; int index;
  found = 0;
  for (index=0;index<nelements_in_sharedframes;index++) {
    	if ( (sharedframes[index].iprime      == iprime) &&
	         (sharedframes[index].jprime      == jprime) &&
	         (sharedframes[index].gprime      == gprime) &&
	         (sharedframes[index].pprime      == pprime) &&
	         (sharedframes[index].iprimeprime == iprimeprime) &&
	         (sharedframes[index].jprimeprime == jprimeprime) &&
	         (sharedframes[index].gprimeprime == gprimeprime) &&
		     (sharedframes[index].pprimeprime == pprimeprime) ) {
		  found = 1;
		}    
  }
  return found;
}

void get_element_of_sharedframes( int index, int* iprime, int* jprime, int* gprime, int* pprime, int* iprimeprime, int* jprimeprime, int* gprimeprime, int* pprimeprime )
{
   *iprime      = sharedframes[index].iprime;
   *jprime      = sharedframes[index].jprime;
   *gprime      = sharedframes[index].gprime;
   *pprime      = sharedframes[index].pprime;
   *iprimeprime = sharedframes[index].iprimeprime;
   *jprimeprime = sharedframes[index].jprimeprime;
   *gprimeprime = sharedframes[index].gprimeprime;
   *pprimeprime = sharedframes[index].pprimeprime;
}

// These data structures are used for computing GROUPSIZE
struct computinggroupsize_structofpage {
  int computinggroupsize_visited;
  int computinggroupsize_groupsize;
};
struct computinggroupsize_structofsegment {
  struct computinggroupsize_structofpage* computinggroupsize_pages;
};
struct computinggroupsize_structofstage {
  struct computinggroupsize_structofsegment* computinggroupsize_segments;
};
struct computinggroupsize_structoftask {
  struct computinggroupsize_structofstage* computinggroupsize_stages;
};
struct computinggroupsize_structoftask* computinggroupsize_tasks = NULL;

void computinggroupsize_allocatememory_segment(int i, int j, int g)
{
  computinggroupsize_tasks[i].computinggroupsize_stages[j].computinggroupsize_segments[g].computinggroupsize_pages = (struct computinggroupsize_structofpage*) malloc(sizeof(struct computinggroupsize_structofpage)*(tasks[i].memoryaccessesdescription[j].npages));
  if (computinggroupsize_tasks[i].computinggroupsize_stages[j].computinggroupsize_segments[g].computinggroupsize_pages==NULL) { printf("malloc failure in computinggroupsize_allocatememory_segment\n"); exit( -1); }
}
void computinggroupsize_freememory_segment(int i, int j, int g)
{
  if (computinggroupsize_tasks[i].computinggroupsize_stages[j].computinggroupsize_segments[g].computinggroupsize_pages!=NULL) {
    free( computinggroupsize_tasks[i].computinggroupsize_stages[j].computinggroupsize_segments[g].computinggroupsize_pages);
    computinggroupsize_tasks[i].computinggroupsize_stages[j].computinggroupsize_segments[g].computinggroupsize_pages = NULL;
  }
}
void computinggroupsize_allocatememory_stage(int i, int j)
{
  int g;
  computinggroupsize_tasks[i].computinggroupsize_stages[j].computinggroupsize_segments  = (struct computinggroupsize_structofsegment*) malloc(sizeof(struct computinggroupsize_structofsegment)*(tasks[i].nsegments_of_stage[j]+1));
  if (computinggroupsize_tasks[i].computinggroupsize_stages[j].computinggroupsize_segments==NULL) { printf("malloc failure in computinggroupsize_allocatememory_stage\n"); exit( -1); }
  for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
    computinggroupsize_allocatememory_segment(i,j,g);
  }
}
void computinggroupsize_freememory_stage(int i, int j)
{
  int g;
  for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
    computinggroupsize_freememory_segment(i,j,g);
  }
  if (computinggroupsize_tasks[i].computinggroupsize_stages[j].computinggroupsize_segments!=NULL) {
    free( computinggroupsize_tasks[i].computinggroupsize_stages[j].computinggroupsize_segments);
    computinggroupsize_tasks[i].computinggroupsize_stages[j].computinggroupsize_segments = NULL;
  }
}
void computinggroupsize_allocatememory_task(int i)
{
  int j;
  computinggroupsize_tasks[i].computinggroupsize_stages  = (struct computinggroupsize_structofstage*) malloc(sizeof(struct computinggroupsize_structofstage)*(tasks[i].nstages+1));
  if (computinggroupsize_tasks[i].computinggroupsize_stages==NULL) { printf("malloc failure in computinggroupsize_allocatememory_task\n"); exit( -1); }
  for (j=1;j<=tasks[i].nstages;j++) {
    computinggroupsize_allocatememory_stage(i,j);
  }
}
void computinggroupsize_freememory_task(int i)
{
  int j;
  for (j=1;j<=tasks[i].nstages;j++) {
    computinggroupsize_freememory_stage(i,j);
  }
  if (computinggroupsize_tasks[i].computinggroupsize_stages!=NULL) {
    free( computinggroupsize_tasks[i].computinggroupsize_stages);
    computinggroupsize_tasks[i].computinggroupsize_stages = NULL;
  }
}
void computinggroupsize_allocatememory_tasks()
{
  int i;
  computinggroupsize_tasks = (struct computinggroupsize_structoftask*) malloc(sizeof(struct computinggroupsize_structoftask)*(ntasks+1));
  if (computinggroupsize_tasks==NULL) { printf("malloc failure in computinggroupsize_allocatememory_tasks\n"); exit( -1); }
  for (i=1;i<=ntasks;i++) {
    computinggroupsize_allocatememory_task(i);
  }
}
void computinggroupsize_freememory_tasks()
{
  int i;
  for (i=1;i<=ntasks;i++) {
    computinggroupsize_freememory_task(i);
  }
  if (computinggroupsize_tasks!=NULL) {
    free( computinggroupsize_tasks);
    computinggroupsize_tasks = NULL;
  }
}
void setvisited(int i,int j,int g,int p)
{
  computinggroupsize_tasks[i].computinggroupsize_stages[j].computinggroupsize_segments[g].computinggroupsize_pages[p].computinggroupsize_visited =  1;
}
void setnotvisited(int i,int j,int g,int p)
{
  computinggroupsize_tasks[i].computinggroupsize_stages[j].computinggroupsize_segments[g].computinggroupsize_pages[p].computinggroupsize_visited =  0;
}
int isvisited(int i,int j,int g,int p)
{
  return computinggroupsize_tasks[i].computinggroupsize_stages[j].computinggroupsize_segments[g].computinggroupsize_pages[p].computinggroupsize_visited;
}
void setgroupsize(int i,int j,int g,int p,int v)
{
  computinggroupsize_tasks[i].computinggroupsize_stages[j].computinggroupsize_segments[g].computinggroupsize_pages[p].computinggroupsize_groupsize = v;
}
int getgroupsize(int i,int j,int g,int p)
{
  return computinggroupsize_tasks[i].computinggroupsize_stages[j].computinggroupsize_segments[g].computinggroupsize_pages[p].computinggroupsize_groupsize;
}
void computinggroupsize_setallverticestonotvisited()
{
  int i; int j; int g; int p;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
        for (p=0;p<=tasks[i].memoryaccessesdescription[j].npages-1;p++) {
          setnotvisited( i, j, g, p);
	    }
	  }
    }
  }
}

int computegroupsize_internal(int i,int j,int g,int p, int visitedsofar)
{
  int iprime;      int jprime;      int gprime;      int pprime;
  int iprimeprime; int jprimeprime; int gprimeprime; int pprimeprime;
  if (!isvisited(i,j,g,p)) {
    setvisited(i,j,g,p);
    visitedsofar = visitedsofar + 1;
    for (iprime=1;iprime<=ntasks;iprime++) {
      for (jprime=1;jprime<=tasks[iprime].nstages;jprime++) {
        for (gprime=1;gprime<=tasks[iprime].nsegments_of_stage[jprime];gprime++) {
          for (pprime=0;pprime<=tasks[iprime].memoryaccessesdescription[jprime].npages-1;pprime++) {
            for (iprimeprime=1;iprimeprime<=ntasks;iprimeprime++) {
              for (jprimeprime=1;jprimeprime<=tasks[iprimeprime].nstages;jprimeprime++) {
                for (gprimeprime=1;gprimeprime<=tasks[iprimeprime].nsegments_of_stage[jprimeprime];gprimeprime++) {
                  for (pprimeprime=0;pprimeprime<=tasks[iprimeprime].memoryaccessesdescription[jprimeprime].npages-1;pprimeprime++) {
					if (is_in_sharedframes(iprime,jprime,gprime,pprime,iprimeprime,jprimeprime,gprimeprime,pprimeprime)) {
					  if ((iprime==i) && (jprime==j) && (gprime==g) && (pprime==p)) {
                        visitedsofar = computegroupsize_internal( iprimeprime,jprimeprime,gprimeprime,pprimeprime,visitedsofar);
					  }
					}
				  }
  	            }
  	          }
  	        }
          }
	    }
	  }
	}
    for (iprime=1;iprime<=ntasks;iprime++) {
      for (jprime=1;jprime<=tasks[iprime].nstages;jprime++) {
        for (gprime=1;gprime<=tasks[iprime].nsegments_of_stage[jprime];gprime++) {
          for (pprime=0;pprime<=tasks[iprime].memoryaccessesdescription[jprime].npages-1;pprime++) {
            for (iprimeprime=1;iprimeprime<=ntasks;iprimeprime++) {
              for (jprimeprime=1;jprimeprime<=tasks[iprimeprime].nstages;jprimeprime++) {
                for (gprimeprime=1;gprimeprime<=tasks[iprimeprime].nsegments_of_stage[jprimeprime];gprimeprime++) {
                  for (pprimeprime=0;pprimeprime<=tasks[iprimeprime].memoryaccessesdescription[jprimeprime].npages-1;pprimeprime++) {
					if (is_in_sharedframes(iprime,jprime,gprime,pprime,iprimeprime,jprimeprime,gprimeprime,pprimeprime)) {
					  if ((iprimeprime==i) && (jprimeprime==j) && (gprimeprime==g) && (pprimeprime==p)) {
                        visitedsofar = computegroupsize_internal( iprime,jprime,gprime,pprime,visitedsofar);
					  }
					}
				  }
  	            }
  	          }
  	        }
          }
	    }
	  }
	}
  }
  return visitedsofar;
}

int computegroupsize(int i,int j,int g,int p)
{
  int return_value;
  computinggroupsize_allocatememory_tasks();
  computinggroupsize_setallverticestonotvisited();
  return_value = computegroupsize_internal( i, j, g, p, 0);
  computinggroupsize_freememory_tasks();
  return return_value;
}  

double remainder( double t1, double t2)
{
  return t1-floor(t1/t2)*t2;
}

double gcd2(double t1, double t2)
{
  double gcd2epsilon = 0.000000001;
  if ((-gcd2epsilon<t2) && (t2<gcd2epsilon)) 
	  return t1;
  else
      return gcd2(t2, remainder(t1,t2) );
}

double lcm2(double t1, double t2)
{
  return t1*t2/gcd2(t1,t2);
}

double lcm_of_Tis(int firstindex, int lastindex)
{
	if (lastindex < firstindex) {
		printf("Error in lcm_of_Tis. This should not happen\n");
		exit(-1);
	}
	if (lastindex == firstindex) {
		return tasks[firstindex].T;
	}
	if (firstindex+1 == lastindex) {
		return lcm2( tasks[firstindex].T, tasks[lastindex].T);
	}
	return lcm2( tasks[firstindex].T, lcm_of_Tis(firstindex+1, lastindex) );
}

void compute_P()
{
  P = lcm_of_Tis(1,ntasks);
}

void compute_derived_parameters()
{
  compute_P();
}

int poweroftwo( int temp)
{
  int t;
  if (temp==0) {
	  return 1;
  }
  if (temp>0) {
    t = poweroftwo( temp/2);
	if (temp%2==0) {
	  return t*t;
	} else {
	  return t*t*2;
	}
  } else {
	printf("Error in function poweroftwo.\n");
	exit(-1);
  }
}

void doit_setallMAtozero()
{
    int i; int j; int p;
    for (i=1;i<=ntasks;i++) {
      for (j=1;j<=tasks[i].nstages;j++) {
        for (p=0;p<=tasks[i].memoryaccessesdescription[j].npages-1;p++) {
          tasks[i].memoryaccessesdescription[j].MA[p] = 0;
        }
      }
    }
}

void doit_apply_mult_to_MA(double mult)
{
    int i; int j; int p;
    for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (p=0;p<=tasks[i].memoryaccessesdescription[j].npages-1;p++) {
           tasks[i].memoryaccessesdescription[j].MA[p] = tasks[i].memoryaccessesdescription[j].MA[p] * mult;
         }
       }
     }
}

void doit_setsharedframes()
{
  int temp;
  makesharedframesempty();
  for (temp=1;temp<=tasks[1].nsegments_of_stage[2];temp++) {
    addelementtosharedframes( 1, 1, 1, temp-1, 1, 2, temp, 0);
  }
  for (temp=1;temp<=tasks[1].nsegments_of_stage[2];temp++) {
    addelementtosharedframes( 1, 3, 1, temp-1, 1, 2, temp, 1);
  }
  addelementtosharedframes( 3, 1, 1, 0, 3, 2, 1, 0);
  addelementtosharedframes( 3, 1, 1, 1, 3, 2, 2, 0);
  addelementtosharedframes( 3, 3, 1, 0, 3, 2, 1, 1);
  addelementtosharedframes( 3, 3, 1, 1, 3, 2, 2, 1);
}

double calculateCAP()
{
  if ((H!=0) && (B!=0)) {
     // CAP = HWSHARE * MEMCAP / (H*B);
     CAP = MEMCAP / (H*B);
  }
} 

void setmethod(int newmethod)
{
  method = newmethod;
}
void setGUROBITIMEOUTPARAMETER(double newGUROBITIMEOUTPARAMETER)
{
  GUROBITIMEOUTPARAMETER = newGUROBITIMEOUTPARAMETER;
}
void setK(double newK)
{
  K = newK;
}
void allocateTaskset(int numtasks){
    ntasks = numtasks;
    tasks             = (struct structoftask*)                  malloc(sizeof(struct structoftask)*(ntasks+1));
    if (tasks==NULL) { printf("malloc failure in allocateTaskset\n"); exit( -1); }
}
void deleteTaskset(){
    if (tasks!=NULL) {
      free( tasks);
      tasks = NULL;
    }
}
void setNumProcessors( int newNumProcessors)
{
  nprocessors = newNumProcessors;
}
void setSpeed( double newspeed)
{
  s = newspeed;
}
void setH( int newH)
{
  H = newH;
  calculateCAP();
}
void setB( int newB)
{
  B = newB;
  calculateCAP();
}
// void setHWSHARE(double newHWSHARE)
// {
//  HWSHARE = newHWSHARE;
//  calculateCAP();
// }
void setMEMCAP(double newMEMCAP)
{
  MEMCAP = newMEMCAP;
  calculateCAP();
}
void settrrdinbusclockcycles( int newtrrd)
{
  trrd = newtrrd;
  setmemoryparameters();
}
void settfawinbusclockcycles( int newtfaw)
{
  tfaw = newtfaw;
  setmemoryparameters();
}
void setwlinbusclockcycles( int newwl)
{
  wl = newwl;
  setmemoryparameters();
}
void setblinbusclockcycles( int newbl)
{
  bl = newbl;
  setmemoryparameters();
}
void settwtrinbusclockcycles( int newtwtr)
{
  twtr = newtwtr;
  setmemoryparameters();
}
void setclinbusclockcyclessettwtrinbusclockcycles( int newcl)
{
  cl = newcl;
  setmemoryparameters();
}
void settrpinbusclockcycles( int newtrp)
{
  trp = newtrp;
  setmemoryparameters();
}
void settrcdinbusclockcycles( int newtrcd)
{
  trcd = newtrcd;
  setmemoryparameters();
}
void settwrinbusclockcycles( int newtwr)
{
  twr = newtwr;
  setmemoryparameters();
}

void addtask( int taskid, double T, double D, int nstages)
{
  tasks[taskid].T = T; tasks[taskid].D = D; tasks[taskid].nstages = nstages;
  tasks[taskid].nsegments_of_stage        =  (int*)                                malloc(sizeof(int)*(nstages+1));
  tasks[taskid].exec_of_stage             =  (double*)                             malloc(sizeof(double)*(nstages+1));
  tasks[taskid].memoryaccessesdescription =  (struct memoryaccessesofstagestruct*) malloc(sizeof(struct memoryaccessesofstagestruct)*(nstages+1));

  if (tasks[taskid].nsegments_of_stage==NULL)        { printf("malloc failure in addtask\n"); exit( -1); }
  if (tasks[taskid].exec_of_stage==NULL)             { printf("malloc failure in addtask\n"); exit( -1); }
  if (tasks[taskid].memoryaccessesdescription==NULL) { printf("malloc failure in addtask\n"); exit( -1); }
}
void deletetask( int taskid)
{
  if (tasks[taskid].nsegments_of_stage!=NULL) {
    free( tasks[taskid].nsegments_of_stage );
    tasks[taskid].nsegments_of_stage = NULL;
  }
  if (tasks[taskid].exec_of_stage!=NULL) {
    free( tasks[taskid].exec_of_stage );
    tasks[taskid].exec_of_stage = NULL;
  }
  if (tasks[taskid].memoryaccessesdescription!=NULL) {
    free( tasks[taskid].memoryaccessesdescription );
    tasks[taskid].memoryaccessesdescription = NULL;
  }
}
void addstage( int taskid, int stageid, int nsegments, double executionrequirement, int np)
{
  tasks[taskid].nsegments_of_stage[stageid]                =                nsegments;
  tasks[taskid].exec_of_stage[stageid]                     =  executionrequirement;
  tasks[taskid].memoryaccessesdescription[stageid].npages  =                    np;
  tasks[taskid].memoryaccessesdescription[stageid].MA = malloc(sizeof(int)*np);

  if (tasks[taskid].memoryaccessesdescription[stageid].MA==NULL)        { printf("malloc failure in addstage\n"); exit( -1); }
}
void deletestage( int taskid, int stageid)
{
  if (tasks[taskid].memoryaccessesdescription[stageid].MA!=NULL) {
    free( tasks[taskid].memoryaccessesdescription[stageid].MA);
    tasks[taskid].memoryaccessesdescription[stageid].MA = NULL;
  }
}

void addMA( int taskid, int stageid, int pageindex, int upper_bound_on_number_of_memory_accesses)
{
  tasks[taskid].memoryaccessesdescription[stageid].MA[pageindex]   =       upper_bound_on_number_of_memory_accesses;
}
void setNre(int newNre)
{
  Nre = newNre;
}
void setINO(int newINO)
{
  INO = newINO;
}

void deallocatetheentiresystem()
{
  int i; int j;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      deletestage( i,j);      
    }
    deletetask( i);
  }
  deleteTaskset();
  freemakesharedframes();
}

void setsystem1(int targetnprocessors, double C12, double mult)
{
   setmethod(3);
   setGUROBITIMEOUTPARAMETER(3600.0);
   setK(20);
   allocateTaskset(3);
   setNumProcessors( targetnprocessors);
   setSpeed( 1.0);
   setH(32);
   setB(16);
   // setHWSHARE(1.0/4.0);
   setMEMCAP( 524288);
   MBCF = 1500000000;
   settrrdinbusclockcycles( 4);
   settfawinbusclockcycles( 20);
   setwlinbusclockcycles( 7);
   setblinbusclockcycles( 8);
   settwtrinbusclockcycles( 5);
   setclinbusclockcyclessettwtrinbusclockcycles( 9);
   settrpinbusclockcycles( 9);
   settrcdinbusclockcycles( 9);
   settwrinbusclockcycles( 10);
   setNre(12);
   addtask( 1,  0.100, 0.100, 3);
   addstage( 1, 1, 1,  0.001, 17);
   addMA( 1, 1,  0,  100*mult);
   addMA( 1, 1,  1,  100*mult);
   addMA( 1, 1,  2,  100*mult);
   addMA( 1, 1,  3,  100*mult);
   addMA( 1, 1,  4,  100*mult);
   addMA( 1, 1,  5,  100*mult);
   addMA( 1, 1,  6,  100*mult);
   addMA( 1, 1,  7,  100*mult);
   addMA( 1, 1,  8,  100*mult);
   addMA( 1, 1,  9,  100*mult);
   addMA( 1, 1, 10,  100*mult);
   addMA( 1, 1, 11,  100*mult);
   addMA( 1, 1, 12,  100*mult);
   addMA( 1, 1, 13,  100*mult);
   addMA( 1, 1, 14,  100*mult);
   addMA( 1, 1, 15,  100*mult);
   addMA( 1, 1, 16,  100*mult);
   addstage( 1, 2, targetnprocessors, C12, 17);
   addMA( 1, 2,  0, 1000*mult);
   addMA( 1, 2,  1, 1000*mult);
   addMA( 1, 2,  2, 1000*mult);
   addMA( 1, 2,  3, 1000*mult);
   addMA( 1, 2,  4, 1000*mult);
   addMA( 1, 2,  5, 1000*mult);
   addMA( 1, 2,  6, 1000*mult);
   addMA( 1, 2,  7, 1000*mult);
   addMA( 1, 2,  8, 1000*mult);
   addMA( 1, 2,  9, 1000*mult);
   addMA( 1, 2, 10, 1000*mult);
   addMA( 1, 2, 11, 1000*mult);
   addMA( 1, 2, 12, 1000*mult);
   addMA( 1, 2, 13, 1000*mult);
   addMA( 1, 2, 14, 1000*mult);
   addMA( 1, 2, 15, 1000*mult);
   addMA( 1, 2, 16, 1000*mult);
   addstage( 1, 3, 1, 0.001, 17);
   addMA( 1, 3,  0,  100*mult);
   addMA( 1, 3,  1,  100*mult);
   addMA( 1, 3,  2,  100*mult);
   addMA( 1, 3,  3,  100*mult);
   addMA( 1, 3,  4,  100*mult);
   addMA( 1, 3,  5,  100*mult);
   addMA( 1, 3,  6,  100*mult);
   addMA( 1, 3,  7,  100*mult);
   addMA( 1, 3,  8,  100*mult);
   addMA( 1, 3,  9,  100*mult);
   addMA( 1, 3, 10,  100*mult);
   addMA( 1, 3, 11,  100*mult);
   addMA( 1, 3, 12,  100*mult);
   addMA( 1, 3, 13,  100*mult);
   addMA( 1, 3, 14,  100*mult);
   addMA( 1, 3, 15,  100*mult);
   addMA( 1, 3, 16,  100*mult);
   addtask( 2,  0.010, 0.010, 1);
   addstage( 2, 1, 1,  0.002, 17);
   addMA( 2, 1,  0,  100*mult);
   addMA( 2, 1,  1,  100*mult);
   addMA( 2, 1,  2,  100*mult);
   addMA( 2, 1,  3,  100*mult);
   addMA( 2, 1,  4,  100*mult);
   addMA( 2, 1,  5,  100*mult);
   addMA( 2, 1,  6,  100*mult);
   addMA( 2, 1,  7,  100*mult);
   addMA( 2, 1,  8,  100*mult);
   addMA( 2, 1,  9,  100*mult);
   addMA( 2, 1, 10,  100*mult);
   addMA( 2, 1, 11,  100*mult);
   addMA( 2, 1, 12,  100*mult);
   addMA( 2, 1, 13,  100*mult);
   addMA( 2, 1, 14,  100*mult);
   addMA( 2, 1, 15,  100*mult);
   addMA( 2, 1, 16,  100*mult);
   addtask( 3,  0.100, 0.044, 3);
   addstage( 3, 1, 1,  0.002, 17);
   addMA( 3, 1,  0,  100*mult);
   addMA( 3, 1,  1,  100*mult);
   addMA( 3, 1,  2,  100*mult);
   addMA( 3, 1,  3,  100*mult);
   addMA( 3, 1,  4,  100*mult);
   addMA( 3, 1,  5,  100*mult);
   addMA( 3, 1,  6,  100*mult);
   addMA( 3, 1,  7,  100*mult);
   addMA( 3, 1,  8,  100*mult);
   addMA( 3, 1,  9,  100*mult);
   addMA( 3, 1, 10,  100*mult);
   addMA( 3, 1, 11,  100*mult);
   addMA( 3, 1, 12,  100*mult);
   addMA( 3, 1, 13,  100*mult);
   addMA( 3, 1, 14,  100*mult);
   addMA( 3, 1, 15,  100*mult);
   addMA( 3, 1, 16,  100*mult);
   addstage( 3, 2, 2,  0.006, 17);
   addMA( 3, 2,  0,  100*mult);
   addMA( 3, 2,  1,  100*mult);
   addMA( 3, 2,  2,  100*mult);
   addMA( 3, 2,  3,  100*mult);
   addMA( 3, 2,  4,  100*mult);
   addMA( 3, 2,  5,  100*mult);
   addMA( 3, 2,  6,  100*mult);
   addMA( 3, 2,  7,  100*mult);
   addMA( 3, 2,  8,  100*mult);
   addMA( 3, 2,  9,  100*mult);
   addMA( 3, 2, 10,  100*mult);
   addMA( 3, 2, 11,  100*mult);
   addMA( 3, 2, 12,  100*mult);
   addMA( 3, 2, 13,  100*mult);
   addMA( 3, 2, 14,  100*mult);
   addMA( 3, 2, 15,  100*mult);
   addMA( 3, 2, 16,  100*mult);
   addstage( 3, 3, 1,  0.002, 17);
   addMA( 3, 3,  0,  100*mult);
   addMA( 3, 3,  1,  100*mult);
   addMA( 3, 3,  2,  100*mult);
   addMA( 3, 3,  3,  100*mult);
   addMA( 3, 3,  4,  100*mult);
   addMA( 3, 3,  5,  100*mult);
   addMA( 3, 3,  6,  100*mult);
   addMA( 3, 3,  7,  100*mult);
   addMA( 3, 3,  8,  100*mult);
   addMA( 3, 3,  9,  100*mult);
   addMA( 3, 3, 10,  100*mult);
   addMA( 3, 3, 11,  100*mult);
   addMA( 3, 3, 12,  100*mult);
   addMA( 3, 3, 13,  100*mult);
   addMA( 3, 3, 14,  100*mult);
   addMA( 3, 3, 15,  100*mult);
   addMA( 3, 3, 16,  100*mult);
   int temp;
   allocatemakesharedframesempty( 2*targetnprocessors+4);
   makesharedframesempty();
   for (temp=1;temp<=tasks[1].nsegments_of_stage[2];temp++) {
     addelementtosharedframes( 1, 1, 1, temp-1, 1, 2, temp, 0);
   }
   for (temp=1;temp<=tasks[1].nsegments_of_stage[2];temp++) {
     addelementtosharedframes( 1, 3, 1, temp-1, 1, 2, temp, 1);
   }
   addelementtosharedframes( 3, 1, 1, 0, 3, 2, 1, 0);
   addelementtosharedframes( 3, 1, 1, 1, 3, 2, 2, 0);
   addelementtosharedframes( 3, 3, 1, 0, 3, 2, 1, 1);
   addelementtosharedframes( 3, 3, 1, 1, 3, 2, 2, 1);
   setINO(970);
}

// this is like setsystem1 but with fewer pages (4 pages instead of 16 pages)
void setsystem1_smaller(int targetnprocessors, double C12, double mult)
{
   setmethod(3);
   setGUROBITIMEOUTPARAMETER(3600.0);
   setK(20);
   allocateTaskset(3);
   setNumProcessors( targetnprocessors);
   setSpeed( 1.0);
   setH(32);
   setB(16);
   // setHWSHARE(1.0/4.0);
   setMEMCAP( 524288);
   MBCF = 1500000000;
   settrrdinbusclockcycles( 4);
   settfawinbusclockcycles( 20);
   setwlinbusclockcycles( 7);
   setblinbusclockcycles( 8);
   settwtrinbusclockcycles( 5);
   setclinbusclockcyclessettwtrinbusclockcycles( 9);
   settrpinbusclockcycles( 9);
   settrcdinbusclockcycles( 9);
   settwrinbusclockcycles( 10);
   setNre(12);
   addtask( 1,  0.100, 0.100, 3);
   addstage( 1, 1, 1,  0.001, 4);
   addMA( 1, 1,  0,  100*mult);
   addMA( 1, 1,  1,  100*mult);
   addMA( 1, 1,  2,  100*mult);
   addMA( 1, 1,  3,  100*mult);
   addstage( 1, 2, targetnprocessors, C12, 4);
   addMA( 1, 2,  0, 1000*mult);
   addMA( 1, 2,  1, 1000*mult);
   addMA( 1, 2,  2, 1000*mult);
   addMA( 1, 2,  3, 1000*mult);
   addstage( 1, 3, 1, 0.001, 4);
   addMA( 1, 3,  0,  100*mult);
   addMA( 1, 3,  1,  100*mult);
   addMA( 1, 3,  2,  100*mult);
   addMA( 1, 3,  3,  100*mult);
   addtask( 2,  0.010, 0.010, 1);
   addstage( 2, 1, 1,  0.002, 4);
   addMA( 2, 1,  0,  100*mult);
   addMA( 2, 1,  1,  100*mult);
   addMA( 2, 1,  2,  100*mult);
   addMA( 2, 1,  3,  100*mult);
   addtask( 3,  0.100, 0.044, 3);
   addstage( 3, 1, 1,  0.002, 4);
   addMA( 3, 1,  0,  100*mult);
   addMA( 3, 1,  1,  100*mult);
   addMA( 3, 1,  2,  100*mult);
   addMA( 3, 1,  3,  100*mult);
   addstage( 3, 2, 2,  0.006, 4);
   addMA( 3, 2,  0,  100*mult);
   addMA( 3, 2,  1,  100*mult);
   addMA( 3, 2,  2,  100*mult);
   addMA( 3, 2,  3,  100*mult);
   addstage( 3, 3, 1,  0.002, 4);
   addMA( 3, 3,  0,  100*mult);
   addMA( 3, 3,  1,  100*mult);
   addMA( 3, 3,  2,  100*mult);
   addMA( 3, 3,  3,  100*mult);
   int temp;
   allocatemakesharedframesempty( 2*targetnprocessors+4);
   makesharedframesempty();
   for (temp=1;temp<=tasks[1].nsegments_of_stage[2];temp++) {
     addelementtosharedframes( 1, 1, 1, temp-1, 1, 2, temp, 0);
   }
   for (temp=1;temp<=tasks[1].nsegments_of_stage[2];temp++) {
     addelementtosharedframes( 1, 3, 1, temp-1, 1, 2, temp, 1);
   }
   addelementtosharedframes( 3, 1, 1, 0, 3, 2, 1, 0);
   addelementtosharedframes( 3, 1, 1, 1, 3, 2, 2, 0);
   addelementtosharedframes( 3, 3, 1, 0, 3, 2, 1, 1);
   addelementtosharedframes( 3, 3, 1, 1, 3, 2, 2, 1);
   setINO(970);
}

void readsystemfromfile( FILE* f)
{
  int i; int j; int p; int temp;
  int iprime;      int jprime;      int gprime;      int pprime;
  int iprimeprime; int jprimeprime; int gprimeprime; int pprimeprime;
  int tempint1; int tempint2;
  double tempdouble1; double tempdouble2;

  fscanf(f,"%d",  &method);
  fscanf(f,"%lf",  &GUROBITIMEOUTPARAMETER);

  fscanf(f,"%d",  &K);
  fscanf(f,"%d",  &nprocessors);
  fscanf(f,"%lf", &s);
  fscanf(f,"%d",  &H);
  fscanf(f,"%d",  &B);
  // fscanf(f,"%lf", &HWSHARE);
  fscanf(f,"%d",  &MEMCAP);
  // CAP = HWSHARE * MEMCAP / (H*B);
  CAP = MEMCAP / (H*B);
  fscanf(f,"%lf",  &MBCF);
  fscanf(f,"%lf",  &trrd );
  fscanf(f,"%lf",  &tfaw );
  fscanf(f,"%lf",  &wl );
  fscanf(f,"%lf",  &bl );
  fscanf(f,"%lf",  &twtr );
  fscanf(f,"%lf",  &cl );
  fscanf(f,"%lf",  &trp );
  fscanf(f,"%lf",  &trcd );
  fscanf(f,"%lf",  &twr );
  setmemoryparameters();
  fscanf(f,"%d",  &Nre       );

  fscanf(f,"%d",  &tempint1);
  allocateTaskset( tempint1);

  for (i=1;i<=ntasks;i++) {
    fscanf(f,"%lf",  &tempdouble1       );
    fscanf(f,"%lf",  &tempdouble2       );
    fscanf(f,"%d",   &tempint1 );
    addtask( i,  tempdouble1, tempdouble2, tempint1);

    for (j=1;j<=tasks[i].nstages;j++) {
      fscanf(f,"%d",   &tempint1     );
      fscanf(f,"%lf",  &tempdouble1  );
      fscanf(f,"%d",   &tempint2 );
      addstage( i, j, tempint1, tempdouble1, tempint2);

      for (p=0;p<=tasks[i].memoryaccessesdescription[j].npages-1;p++) {
        fscanf(f,"%d",   &tempint1 );
        addMA( i, j,  p,  tempint1);
      }
    }
  }
  fscanf(f,"%d",  &tempint1 );
  allocatemakesharedframesempty( tempint1);
  for (temp=1;temp<=tempint1;temp++) {
    fscanf(f,"%d %d %d %d %d %d %d %d", &iprime, &jprime, &gprime, &pprime, &iprimeprime, &jprimeprime, &gprimeprime, &pprimeprime );
    addelementtosharedframes( iprime, jprime, gprime, pprime, iprimeprime, jprimeprime, gprimeprime, pprimeprime );
  }
  fscanf(f,"%d",  &INO       );
}

void printsystemtofile( FILE* f)
{
  int i; int j; int p; int temp;
  int iprime;      int jprime;      int gprime;      int pprime;
  int iprimeprime; int jprimeprime; int gprimeprime; int pprimeprime;

  fprintf(f,"%d \n",  method);
  fprintf(f,"%lf \n",  GUROBITIMEOUTPARAMETER);
  fprintf(f,"\n");

  fprintf(f,"%d \n",  K);
  fprintf(f,"%d \n",  nprocessors);
  fprintf(f,"%lf \n", s);
  fprintf(f,"%d\n",   H);
  fprintf(f,"%d\n",   B);
  // fprintf(f,"%lf\n",  HWSHARE);
  fprintf(f,"%d\n",   MEMCAP);
  fprintf(f,"%lf\n",  MBCF );
  fprintf(f,"%lf\n",  trrd );
  fprintf(f,"%lf\n",  tfaw );
  fprintf(f,"%lf\n",  wl );
  fprintf(f,"%lf\n",  bl );
  fprintf(f,"%lf\n",  twtr );
  fprintf(f,"%lf\n",  cl );
  fprintf(f,"%lf\n",  trp );
  fprintf(f,"%lf\n",  trcd );
  fprintf(f,"%lf\n",  twr );
  fprintf(f,"%d\n",  Nre       );
  fprintf(f,"\n");

  fprintf(f,"%d\n",  ntasks);
  fprintf(f,"\n");
  for (i=1;i<=ntasks;i++) {
    fprintf(f,"%lf ",  tasks[i].T       );
    fprintf(f,"%lf ",  tasks[i].D       );
    fprintf(f,"%d\n",   tasks[i].nstages );
    for (j=1;j<=tasks[i].nstages;j++) {
      fprintf(f,"%d %lf %d\n",  tasks[i].nsegments_of_stage[j], tasks[i].exec_of_stage[j], tasks[i].memoryaccessesdescription[j].npages);
      for (p=0;p<=tasks[i].memoryaccessesdescription[j].npages-1;p++) {
        fprintf(f,"%d ",   tasks[i].memoryaccessesdescription[j].MA[p] );
      }
      fprintf(f,"\n");
    }
    fprintf(f,"\n");
  }  

  fprintf(f,"%d\n",  nelements_in_sharedframes       );
  for (temp=1;temp<=nelements_in_sharedframes;temp++) {
    get_element_of_sharedframes( temp-1, &iprime, &jprime, &gprime, &pprime, &iprimeprime, &jprimeprime, &gprimeprime, &pprimeprime );
    fprintf(f,"%d %d %d %d %d %d %d %d\n", iprime, jprime, gprime, pprime, iprimeprime, jprimeprime, gprimeprime, pprimeprime );
  }
  fprintf(f,"%d\n",  INO       );
}
void printsystemtofilewithname( char* fn)
{
  FILE* f;
  f = fopen( fn, "w");
  printsystemtofile( f);
  fclose( f);
}

void printsystemtofilewithname_and_state_success( char* fn, int success)
{
  FILE* f;
  f = fopen( fn, "w");
  printsystemtofile( f);
  fprintf( f, "success = %d\n", success);
  fclose( f);
}

void readsystem(char* fn)
{
  FILE* f;
  if (fn==NULL) {
    setsystem1( 4, 0.005, 0);
  } else {
    f = fopen( fn, "r");
    readsystemfromfile( f);
    fclose( f);
  }
  compute_derived_parameters();
}

void print_task( int i)
{
  int j;
  printf("T[%d]       = %lf\n", i, tasks[i].T);
  printf("D[%d]       = %lf\n", i, tasks[i].D);
  printf("nstages[%d] = %d\n", i, tasks[i].nstages);
  for (j=1;j<=tasks[i].nstages;j++) {
    printf("  nseg[%d][%d] = %d\n",  i, j, tasks[i].nsegments_of_stage[j]);
    printf("  c[%d][%d]    = %lf\n", i, j, tasks[i].exec_of_stage[j]);
  }
}

void print_platform_parameters()
{
  printf("m = %d, s = %lf\n", nprocessors, s);
  printf("\n");
}

void print_taskset_parameters()
{
  int i;
  printf("n = %d\n", ntasks);
  for (i=1;i<=ntasks;i++) {
    print_task( i);
  }
  printf("P            = %lf\n", P);
}

void printsystem()
{
  print_platform_parameters();
  print_taskset_parameters();
  printmemoryparameters();
}

void initializesystem()
{
   readsystem( inputfilename);
}

#if CALLGUROBITHROUGHAPI
  GRBenv *env = NULL;
  GRBmodel *model = NULL;
#else
#endif                    
  int error = 0;
  double* sol;
  int nelements_of_constr;
  int* ind;
  double* val;
  char constraint_sense;
  double constraint_rhs;
  int nelements_of_obj;
  double* obj;
  char* vtype;
  char** varnames;
  int optimstatus;
  double objval;
  
  struct myvarstruct {
    int index;          
    char vtype;
    char varname[MAXVARIABLESTRINGLENGTH];          
  };
  int nvars_in_myvars;
  struct myvarstruct* myvars;

void allocate_variables_needed_for_interacting_with_Gurobi()
{
    sol      =  (double*)             malloc(sizeof(double)*MAXNVARS);
    ind      =  (int*)                malloc(sizeof(int)*MAXNVARS);
    val      =  (double*)             malloc(sizeof(double)*MAXNVARS);
    obj      =  (double*)             malloc(sizeof(double)*MAXNVARS);
    vtype    =  (char*)               malloc(sizeof(char)*MAXNVARS);
    varnames =  (char**)              malloc(sizeof(char*)*MAXNVARS);
    myvars   =  (struct myvarstruct*) malloc(sizeof(struct myvarstruct)*MAXNVARS);

    if (sol==NULL)          { printf("malloc failure in allocate_variables_needed_for_interacting_with_Gurobi. sol\n");      exit( -1); }
    if (ind==NULL)          { printf("malloc failure in allocate_variables_needed_for_interacting_with_Gurobi. ind\n");      exit( -1); }
    if (val==NULL)          { printf("malloc failure in allocate_variables_needed_for_interacting_with_Gurobi. val\n");      exit( -1); }
    if (obj==NULL)          { printf("malloc failure in allocate_variables_needed_for_interacting_with_Gurobi. obj\n");      exit( -1); }
    if (vtype==NULL)        { printf("malloc failure in allocate_variables_needed_for_interacting_with_Gurobi. vtype\n");    exit( -1); }
    if (varnames==NULL)     { printf("malloc failure in allocate_variables_needed_for_interacting_with_Gurobi. varnames\n"); exit( -1); }
    if (myvars==NULL)       { printf("malloc failure in allocate_variables_needed_for_interacting_with_Gurobi. myvars\n");   exit( -1); }
}
void free_variables_needed_for_interacting_with_Gurobi()
{
    free( sol);
    free( ind);
    free( val);
    free( obj);
    free( vtype);
    free( varnames);
    free( myvars);

    sol = NULL;
    ind = NULL;
    val = NULL;
    obj = NULL;
    vtype = NULL;
    varnames = NULL;
    myvars = NULL;
}

int getUBNOMR()
{
   int i; int j; int temp;
   int local_counter;
   local_counter = 0;
   for (i=1;i<=ntasks;i++) {
     temp = 0;
     for (j=1;j<=tasks[i].nstages;j++) {
       temp = maxint2(temp, tasks[i].nsegments_of_stage[j] );
     }
     local_counter = local_counter + temp;
   }
   return local_counter;
}
int getLIMIT1()
{
  int temp;
  temp = minint2(nprocessors-1,getUBNOMR()-1);
  return temp;
}
int getLIMIT2()
{
  int temp;
  temp = minint2(nprocessors-1,getUBNOMR()-1)+Nre;
  return temp;
}

double getmaxD()
{
  int i;
  double maxD;
  maxD = tasks[1].D;
  for (i=1;i<=ntasks;i++) {
	  if (maxD < tasks[i].D) {
	    maxD = tasks[i].D;
	  }
  }
  return maxD;
}

int getnumberofmemoryaccessesofajob(int iprime)
{
	int jprime;
	int gprime;
	int pprime;
	int counter;
	counter = 0;
    for (jprime=1;jprime<=tasks[iprime].nstages;jprime++) {
      for (gprime=1;gprime<=tasks[iprime].nsegments_of_stage[jprime];gprime++) {
        for (pprime=0;pprime<=tasks[iprime].memoryaccessesdescription[jprime].npages-1;pprime++) {
          counter = counter +   tasks[iprime].memoryaccessesdescription[jprime].MA[pprime];
		}
	  }
	}
	return counter;
}


double getmaxnmemoryaccessesofsystem()
{
  int i; int iprime;
  int largestsofar;
  int counter;
  int njobs;
  largestsofar = 0;
  for (i=1;i<=ntasks;i++) {    
    counter = 0;
    for (iprime=1;iprime<=ntasks;iprime++) {    
      njobs = ceil( tasks[i].D/(tasks[iprime].T))+1;
      counter = counter + njobs * getnumberofmemoryaccessesofajob(iprime);
    }
    largestsofar = maxint2( largestsofar, counter);
  }
  return largestsofar;
}

double getBIGparteq69()
{
  return getmaxnmemoryaccessesofsystem()*(1.0/SCALINGFACTORNACCESSES);;
}

double getBIGparteq70()
{
  return maxdouble2(1.0,Lconf+Linter)*getBIGparteq69();
}
double getBIGparteq71()
{
  return (P+getmaxD())*nprocessors*maxdouble2(1,s);
}

double getBIG()
{
  return maxdouble2( getBIGparteq70(), getBIGparteq71() );
}

double getBIGfor_x_and_o_for_a_given_i_and_j(int i, int j)
{
   return ((tasks[i].memoryaccessesdescription[j].npages)* B);
}

double getBIGfor_util_constraints()
{
   return nprocessors;
}

void addloadfactorofcells()
{
            	myvars[nvars_in_myvars].index = nvars_in_myvars;
            	myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
            	sprintf( myvars[nvars_in_myvars].varname,"loadfactorofcells");
				nvars_in_myvars = nvars_in_myvars + 1;
}

void addutilconsideringcont()
{
            	myvars[nvars_in_myvars].index = nvars_in_myvars;
            	myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
            	sprintf( myvars[nvars_in_myvars].varname,"utilconsideringcont");
		nvars_in_myvars = nvars_in_myvars + 1;
}

void addloadofdeadline(int i)
{
            	myvars[nvars_in_myvars].index = nvars_in_myvars;
            	myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
            	sprintf( myvars[nvars_in_myvars].varname,"loadofdeadline_%d", i);
		nvars_in_myvars = nvars_in_myvars + 1;
}

void addmyobj()
{
            	myvars[nvars_in_myvars].index = nvars_in_myvars;
            	myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
            	sprintf( myvars[nvars_in_myvars].varname,"myobj");
		nvars_in_myvars = nvars_in_myvars + 1;
}

#if CALLGUROBITHROUGHAPI

#else

void myaddconstr( int nelements_of_constr, int* ind, double* val, char constraint_sense, double constraint_rhs)
{
   int tempindex;
   int therewasazero;
   int indexofzero;

   therewasazero = 1;
   while (therewasazero) {
     therewasazero = 0;
     tempindex = 0;
     while (tempindex<nelements_of_constr) {
       if (val[tempindex]==0.0) {
         therewasazero = 1;
         indexofzero = tempindex;
       }
       tempindex++;
     }
     if (therewasazero) {
       for (tempindex=indexofzero+1;tempindex<nelements_of_constr;tempindex++) {
         val[tempindex-1] = val[tempindex];
       }
       nelements_of_constr--;
     }
   }

   for (tempindex=0;tempindex<nelements_of_constr;tempindex++) {  
     if (tempindex==0) {
       if (val[tempindex]==1.0) {
           fprintf( gurobithroughcommandlinelpfile, "  %s", myvars[ind[tempindex]].varname );
       } else {
         if (val[tempindex]==-1.0) {
           fprintf( gurobithroughcommandlinelpfile, "  - %s", myvars[ind[tempindex]].varname );
         } else { 
           if (val[tempindex]>0) {
             fprintf( gurobithroughcommandlinelpfile, "  %20.15lf %s", val[tempindex], myvars[ind[tempindex]].varname );
           } else {
             fprintf( gurobithroughcommandlinelpfile, "  - %20.15lf %s", -val[tempindex], myvars[ind[tempindex]].varname );
           }
         }
       }
     } else {
       if (val[tempindex]==1.0) {
           fprintf( gurobithroughcommandlinelpfile, " + %s", myvars[ind[tempindex]].varname );
       } else {
         if (val[tempindex]==-1.0) {
           fprintf( gurobithroughcommandlinelpfile, " - %s", myvars[ind[tempindex]].varname );
         } else { 
           if (val[tempindex]>0) {
             fprintf( gurobithroughcommandlinelpfile, " + %20.15lf %s", val[tempindex], myvars[ind[tempindex]].varname );
           } else {
             fprintf( gurobithroughcommandlinelpfile, " - %20.15lf %s", -val[tempindex], myvars[ind[tempindex]].varname );
           }
         }
       }
     }
   }      
   if (constraint_sense=='=') {
     fprintf( gurobithroughcommandlinelpfile, " = ");
   } else {
     if (constraint_sense=='<') {
       fprintf( gurobithroughcommandlinelpfile, " <= ");
     } else {
       if (constraint_sense=='>') {
         fprintf( gurobithroughcommandlinelpfile, " >= ");
       } else {
         printf("Error in myaddconstr\n");
         exit(-1);
       }
     }
   }
   fprintf( gurobithroughcommandlinelpfile, " %20.15lf", constraint_rhs);
   fprintf( gurobithroughcommandlinelpfile, "\n");
}

#endif

void addconstraintutilconsideringcont()
{
  int index;
  char searchstr[200];
  int i;
  nelements_of_constr = 0;
  for (i=1;i<=ntasks;i++) {
    sprintf(searchstr,"cu_%d", i);
    index = locatevariablenameinmyvars(searchstr);
    ind[nelements_of_constr] = index;
    val[nelements_of_constr] = (1.0/tasks[i].T)/(nprocessors*s);
    nelements_of_constr = nelements_of_constr + 1;
  }
  sprintf(searchstr,"utilconsideringcont");
  index = locatevariablenameinmyvars(searchstr);
  ind[nelements_of_constr] = index;
  val[nelements_of_constr] = -1;
  nelements_of_constr = nelements_of_constr + 1;

  constraint_sense = GRB_EQUAL; 
  constraint_rhs = 0;

#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) printf("Error in addconstraintutilconsideringcont\n"); exit(-1);
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
}

void addconstraintloadofdeadline(int i)
{
  int index;
  char searchstr[200];
  int iprime;
  double num; double denom;
  nelements_of_constr = 0;
  for (iprime=1;iprime<=ntasks;iprime++) {
    sprintf(searchstr,"cu_%d", iprime);
    index = locatevariablenameinmyvars(searchstr);
    num =   maxdouble2( floor((tasks[i].D - tasks[iprime].D)/tasks[iprime].T)+1, 0);
    denom = nprocessors * s * tasks[i].D;
    if (num!=0.0) {
      ind[nelements_of_constr] = index;
      val[nelements_of_constr] = num / denom;
      nelements_of_constr = nelements_of_constr + 1;
    }
  }
  sprintf(searchstr,"loadofdeadline_%d", i);
  index = locatevariablenameinmyvars(searchstr);
  ind[nelements_of_constr] = index;
  val[nelements_of_constr] = -1;
  nelements_of_constr = nelements_of_constr + 1;

  constraint_sense = GRB_EQUAL; 
  constraint_rhs = 0;

#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) printf("Error in addconstrainloadofdeadline\n"); exit(-1);
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
}

void addconstraintlowerboundonmyobj(char* s)
{
  int index;
  char searchstr[200];
  nelements_of_constr = 0;

  strcpy(searchstr,s);
  index = locatevariablenameinmyvars(searchstr);
  ind[nelements_of_constr] = index;
  val[nelements_of_constr] = 1;
  nelements_of_constr = nelements_of_constr + 1;

  sprintf(searchstr,"myobj");
  index = locatevariablenameinmyvars(searchstr);
  ind[nelements_of_constr] = index;
  val[nelements_of_constr] = -1;
  nelements_of_constr = nelements_of_constr + 1;

  constraint_sense = GRB_LESS_EQUAL; 
  constraint_rhs = 0;

#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) printf("Error in addconstraintlowerboundonmyobj\n"); exit(-1);
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
}

void addconstraintmyobj()
{
  int i;
  char tempstr[200];
  addconstraintlowerboundonmyobj("loadfactorofcells");
  addconstraintlowerboundonmyobj("utilconsideringcont");
  for (i=1;i<=ntasks;i++) {
      sprintf(tempstr,"loadofdeadline_%d", i);
      addconstraintlowerboundonmyobj(tempstr);
  }
}

void addcuij()
{
  int i; int j;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
            	myvars[nvars_in_myvars].index = nvars_in_myvars;
            	myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
            	sprintf( myvars[nvars_in_myvars].varname,"cu_%d_%d", i,j);
				nvars_in_myvars = nvars_in_myvars + 1;
    }
  }
}

void addcui()
{
  int i;
  for (i=1;i<=ntasks;i++) {
            	myvars[nvars_in_myvars].index = nvars_in_myvars;
            	myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
            	sprintf( myvars[nvars_in_myvars].varname,"cu_%d", i);
				nvars_in_myvars = nvars_in_myvars + 1;
  }
}
void addetaui()
{
  int i;
  for (i=1;i<=ntasks;i++) {
            	myvars[nvars_in_myvars].index = nvars_in_myvars;
            	myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
            	sprintf( myvars[nvars_in_myvars].varname,"etau_%d", i);
				nvars_in_myvars = nvars_in_myvars + 1;
  }
}
void addbspuij()
{
  int i; int j;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
            	myvars[nvars_in_myvars].index = nvars_in_myvars;
            	myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
            	sprintf( myvars[nvars_in_myvars].varname,"bspu_%d_%d", i,j);
				nvars_in_myvars = nvars_in_myvars + 1;
    }
  }
}
void addspuij()
{
  int i; int j;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
            	myvars[nvars_in_myvars].index = nvars_in_myvars;
            	myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
            	sprintf( myvars[nvars_in_myvars].varname,"spu_%d_%d", i,j);
				nvars_in_myvars = nvars_in_myvars + 1;
    }
  }
}

void addtprimes()
{
  int iprime; int qprime; int jprime; int fprime; int k;
  for (iprime=1;iprime<=ntasks;iprime++) {
    for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
      for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
        for (fprime=0;fprime<=1;fprime++) {
          for (k=1;k<=K;k++) {
            	myvars[nvars_in_myvars].index = nvars_in_myvars;
            	myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
            	sprintf( myvars[nvars_in_myvars].varname, "t_%d_%d_%d_%d_%d", iprime,qprime,jprime,fprime,k);
				nvars_in_myvars = nvars_in_myvars + 1;
		  }
		}
	  }
	}
  }
}
void addI()
{
  int i; int q;
  int iprime; int qprime; int jprime; int fprime; int k;
  for (i=1;i<=ntasks;i++) {
    for (q=0;q<=(P/tasks[i].T);q++) {
      for (iprime=1;iprime<=ntasks;iprime++) {
        for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
          for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
            for (fprime=0;fprime<=1;fprime++) {
              for (k=1;k<=K;k++) {
            	myvars[nvars_in_myvars].index = nvars_in_myvars;
            	myvars[nvars_in_myvars].vtype = GRB_BINARY;
            	sprintf( myvars[nvars_in_myvars].varname, "I_%d_%d_%d_%d_%d_%d_%d", i,q,iprime,qprime,jprime,fprime,k);
				nvars_in_myvars = nvars_in_myvars + 1;
		      }
		    }
		  }
		}
	  }
	}
  }
}
void addr()
{
  int i;
  int iprime; int qprime; int jprime; int fprime; int k;
  for (i=1;i<=ntasks;i++) {
    for (iprime=1;iprime<=ntasks;iprime++) {
      for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
        for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
          for (fprime=0;fprime<=1;fprime++) {
            for (k=1;k<=K;k++) {
            	myvars[nvars_in_myvars].index = nvars_in_myvars;
            	myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
            	sprintf( myvars[nvars_in_myvars].varname, "r_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
				nvars_in_myvars = nvars_in_myvars + 1;
		    }
		  }
	    }
	  }
	}
  }
}
void addaj()
{
  int i; int iprime; int qprime; int jprime; int fprime; int k;
  for (i=1;i<=ntasks;i++) {
    for (iprime=1;iprime<=ntasks;iprime++) {
      for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
        for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
          for (fprime=0;fprime<=1;fprime++) {
            for (k=1;k<=K;k++) {
              myvars[nvars_in_myvars].index = nvars_in_myvars;
              myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
              sprintf( myvars[nvars_in_myvars].varname,"aj_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
			  nvars_in_myvars = nvars_in_myvars + 1;
		    }
		  }
	    }
	  }
	}
  }
}
void addwjf()
{
  int i; int iprime; int qprime; int jprime; int fprime; int k;
  for (i=1;i<=ntasks;i++) {
    for (iprime=1;iprime<=ntasks;iprime++) {
      for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
        for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
          for (fprime=0;fprime<=1;fprime++) {
            for (k=1;k<=K;k++) {
              myvars[nvars_in_myvars].index = nvars_in_myvars;
              myvars[nvars_in_myvars].vtype = GRB_BINARY;
              sprintf( myvars[nvars_in_myvars].varname, "wjf_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
			  nvars_in_myvars = nvars_in_myvars + 1;
		    }
		  }
		}
	  }
	}
  }
}
void addwjsf()
{
  int i; int j; int iprime; int qprime; int jprime; int fprime; int k;
  for (i=1;i<=ntasks;i++) {
    for (j=0;j<=tasks[i].nstages-1;j++) {
      for (iprime=1;iprime<=ntasks;iprime++) {
        for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
          for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
            for (fprime=0;fprime<=1;fprime++) {
              for (k=1;k<=K;k++) {
            	myvars[nvars_in_myvars].index = nvars_in_myvars;
            	myvars[nvars_in_myvars].vtype = GRB_BINARY;
            	sprintf( myvars[nvars_in_myvars].varname, "wjsf_%d_%d_%d_%d_%d_%d_%d", i,j,iprime,qprime,jprime,fprime,k);
				nvars_in_myvars = nvars_in_myvars + 1;
		      }
		    }
		  }
		}
	  }
	}
  }
}
void addwjss()
{
  int i; int j; int iprime; int qprime; int jprime; int fprime; int k;
  for (i=1;i<=ntasks;i++) {
    for (j=0;j<=tasks[i].nstages-1;j++) {
      for (iprime=1;iprime<=ntasks;iprime++) {
        for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
          for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
            for (fprime=0;fprime<=1;fprime++) {
              for (k=1;k<=K;k++) {
            	myvars[nvars_in_myvars].index = nvars_in_myvars;
            	myvars[nvars_in_myvars].vtype = GRB_BINARY;
            	sprintf( myvars[nvars_in_myvars].varname, "wjss_%d_%d_%d_%d_%d_%d_%d", i,j,iprime,qprime,jprime,fprime,k);
				nvars_in_myvars = nvars_in_myvars + 1;
		      }
		    }
		  }
		}
	  }
	}
  }
}
void addwjt()
{
  int i; int iprime; int qprime; int jprime; int fprime; int k;
  for (i=1;i<=ntasks;i++) {
    for (iprime=1;iprime<=ntasks;iprime++) {
      for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
        for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
          for (fprime=0;fprime<=1;fprime++) {
            for (k=1;k<=K;k++) {
              myvars[nvars_in_myvars].index = nvars_in_myvars;
              myvars[nvars_in_myvars].vtype = GRB_BINARY;
              sprintf( myvars[nvars_in_myvars].varname, "wjt_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
			  nvars_in_myvars = nvars_in_myvars + 1;
		    }
		  }
		}
	  }
	}
  }
}
void addw()
{
  int i; int iprime; int qprime; int jprime; int fprime; int k;
  for (i=1;i<=ntasks;i++) {
    for (iprime=1;iprime<=ntasks;iprime++) {
      for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
        for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
          for (fprime=0;fprime<=1;fprime++) {
            for (k=1;k<=K;k++) {
              myvars[nvars_in_myvars].index = nvars_in_myvars;
              myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
              sprintf( myvars[nvars_in_myvars].varname,"w_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
			  nvars_in_myvars = nvars_in_myvars + 1;
		    }
		  }
	    }
	  }
	}
  }
}
void addwi()
{
  int k;
    for (k=1;k<=K;k++) {
      myvars[nvars_in_myvars].index = nvars_in_myvars;
      myvars[nvars_in_myvars].vtype = GRB_BINARY;
      sprintf( myvars[nvars_in_myvars].varname,"wi_%d", k);
      nvars_in_myvars = nvars_in_myvars + 1;
    }
}

void addmb()
{
  int i; int j; int g; int b;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
        for (b=0;b<=B-1;b++) {
	      myvars[nvars_in_myvars].index = nvars_in_myvars;
          myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
          sprintf( myvars[nvars_in_myvars].varname,"mb_%d_%d_%d_%d", i,j,g,b);
		  nvars_in_myvars = nvars_in_myvars + 1;
	    }
	  }
	}
  }
}
void addmmb()
{
  int i; int iprime; int jprime; int gprime; int b;
  for (i=1;i<=ntasks;i++) {
    for (iprime=1;iprime<=ntasks;iprime++) {
      for (jprime=1;jprime<=tasks[iprime].nstages;jprime++) {
        for (gprime=1;gprime<=tasks[iprime].nsegments_of_stage[jprime];gprime++) {
          for (b=0;b<=B-1;b++) {
			myvars[nvars_in_myvars].index = nvars_in_myvars;
            myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
            sprintf( myvars[nvars_in_myvars].varname,"mmb_%d_%d_%d_%d_%d", i,iprime,jprime,gprime,b);
			nvars_in_myvars = nvars_in_myvars + 1;
		  }
	    }
	  }
	}
  }
}

void addmmbo()
{
  int i; int j; int g; int b;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
        for (b=0;b<=B-1;b++) {
	      myvars[nvars_in_myvars].index = nvars_in_myvars;
          myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
          sprintf( myvars[nvars_in_myvars].varname,"mmbo_%d_%d_%d_%d", i,j,g,b);
		  nvars_in_myvars = nvars_in_myvars + 1;
		}
	  }
	}
  }
}

void addo()
{
  int i; int j; int g; int p; int h; int b;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
        for (p=0;p<=tasks[i].memoryaccessesdescription[j].npages-1;p++) {
          for (h=0;h<=H-1;h++) {
            for (b=0;b<=B-1;b++) {
	          myvars[nvars_in_myvars].index = nvars_in_myvars;
              myvars[nvars_in_myvars].vtype = GRB_BINARY;
              sprintf( myvars[nvars_in_myvars].varname,"o_%d_%d_%d_%d_%d_%d", i,j,g,p,h,b);
		      nvars_in_myvars = nvars_in_myvars + 1;
	        }
	      }
	    }
	  }
	}
  }
}
void addino()
{
  int h; int b;
  for (h=0;h<=H-1;h++) {
    for (b=0;b<=B-1;b++) {
      myvars[nvars_in_myvars].index = nvars_in_myvars;
      myvars[nvars_in_myvars].vtype = GRB_INTEGER;
      sprintf( myvars[nvars_in_myvars].varname,"ino_%d_%d", h,b);
      nvars_in_myvars = nvars_in_myvars + 1;
    }
  }
}
void addx()
{
  int i; int j; int g; int h;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
        for (h=0;h<=H-1;h++) {
	      myvars[nvars_in_myvars].index = nvars_in_myvars;
          myvars[nvars_in_myvars].vtype = GRB_BINARY;
          sprintf( myvars[nvars_in_myvars].varname,"x_%d_%d_%d_%d", i,j,g,h);
		  nvars_in_myvars = nvars_in_myvars + 1;
	    }
	  }
	}
  }
}
void addcm()
{
  int i; int j; int g;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
	    myvars[nvars_in_myvars].index = nvars_in_myvars;
        myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
        sprintf( myvars[nvars_in_myvars].varname,"cm_%d_%d_%d", i,j,g);
		nvars_in_myvars = nvars_in_myvars + 1;
	  }
	}
  }
}
void addse()
{
  int i; int j; int g;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
	    myvars[nvars_in_myvars].index = nvars_in_myvars;
        myvars[nvars_in_myvars].vtype = GRB_BINARY;
        sprintf( myvars[nvars_in_myvars].varname,"se_%d_%d_%d", i,j,g);
		nvars_in_myvars = nvars_in_myvars + 1;
	  }
	}
  }
}
void addcoat()
{
  int i; int j; int g; int b;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
        for (b=0;b<=B-1;b++) {
	      myvars[nvars_in_myvars].index = nvars_in_myvars;
          myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
          sprintf( myvars[nvars_in_myvars].varname,"coat_%d_%d_%d_%d", i,j,g,b);
		  nvars_in_myvars = nvars_in_myvars + 1;
	    }
	  }
	}
  }
}

void addoao()
{
  int i; int j; int g; int b;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
        for (b=0;b<=B-1;b++) {
	      myvars[nvars_in_myvars].index = nvars_in_myvars;
          myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
          sprintf( myvars[nvars_in_myvars].varname,"oao_%d_%d_%d_%d", i,j,g,b);
		  nvars_in_myvars = nvars_in_myvars + 1;
	    }
	  }
	}
  }
}

void addbc1()
{
  int i; int j; int g; int b;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
        for (b=0;b<=B-1;b++) {
	      myvars[nvars_in_myvars].index = nvars_in_myvars;
          myvars[nvars_in_myvars].vtype = GRB_BINARY;
          sprintf( myvars[nvars_in_myvars].varname,"bc1_%d_%d_%d_%d", i,j,g,b);
		  nvars_in_myvars = nvars_in_myvars + 1;
	    }
	  }
	}
  }
}
void addbc2()
{
  int i; int j; int g; int b;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
        for (b=0;b<=B-1;b++) {
	      myvars[nvars_in_myvars].index = nvars_in_myvars;
          myvars[nvars_in_myvars].vtype = GRB_BINARY;
          sprintf( myvars[nvars_in_myvars].varname,"bc2_%d_%d_%d_%d", i,j,g,b);
		  nvars_in_myvars = nvars_in_myvars + 1;
	    }
	  }
	}
  }
}
void addbc3()
{
  int i; int j; int g; int b;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
        for (b=0;b<=B-1;b++) {
	      myvars[nvars_in_myvars].index = nvars_in_myvars;
          myvars[nvars_in_myvars].vtype = GRB_BINARY;
          sprintf( myvars[nvars_in_myvars].varname,"bc3_%d_%d_%d_%d", i,j,g,b);
		  nvars_in_myvars = nvars_in_myvars + 1;
	    }
	  }
	}
  }
}
void addbc4()
{
  int i; int j; int g; int b;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
        for (b=0;b<=B-1;b++) {
	      myvars[nvars_in_myvars].index = nvars_in_myvars;
          myvars[nvars_in_myvars].vtype = GRB_BINARY;
          sprintf( myvars[nvars_in_myvars].varname,"bc4_%d_%d_%d_%d", i,j,g,b);
		  nvars_in_myvars = nvars_in_myvars + 1;
	    }
	  }
	}
  }
}

void addoat()
{
  int i; int j; int g; int b;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
        for (b=0;b<=B-1;b++) {
	      myvars[nvars_in_myvars].index = nvars_in_myvars;
          myvars[nvars_in_myvars].vtype = GRB_CONTINUOUS;
          sprintf( myvars[nvars_in_myvars].varname,"oat_%d_%d_%d_%d", i,j,g,b);
		  nvars_in_myvars = nvars_in_myvars + 1;
	    }
	  }
	}
  }
}

void addbu()
{
  int i; int j; int g; int b;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
        for (b=0;b<=B-1;b++) {
	      myvars[nvars_in_myvars].index = nvars_in_myvars;
          myvars[nvars_in_myvars].vtype = GRB_BINARY;
          sprintf( myvars[nvars_in_myvars].varname,"bu_%d_%d_%d_%d", i,j,g,b);
		  nvars_in_myvars = nvars_in_myvars + 1;
	    }
	  }
	}
  }
}

int locatevariablenameinmyvars(char* searchstr)
{
	int tempindex;
	for (tempindex=0;tempindex<nvars_in_myvars;tempindex++) {
		if (strcmp( searchstr, myvars[tempindex].varname)==0)	{
		  return tempindex;
		}
	}
	printf("An error has occured in locatevariablenameinmyvars. inputparameter = %s\n", searchstr); 
	exit (-1);
	return -1;
}

void create_tables_with_variable_names()
{
    int i;

    nvars_in_myvars = 0;

    addloadfactorofcells();
    addutilconsideringcont();
    for (i=1;i<=ntasks;i++) { addloadofdeadline(i); }
    addmyobj();

    addcuij();
    addcui();
    addetaui();
    addbspuij();
    addspuij();
	addtprimes();
	addI();
	addr();
    addaj();
	addwjf();
	addwjsf();
	addwjss();
	addwjt();
    addw();
    addwi();

    addmb();
    addmmb();
    addmmbo();
	
	addo();
    addino();

    addx();

    addcm();
	addse();
    addcoat();

    addoao();
    addbc1();
    addbc2();
    addbc3();
    addbc4();
    addoat();
    addbu();
}

void fillobj_for_objective_function()
{
   int index;
   char searchstr[200];
   int temp;
   nelements_of_obj = nvars_in_myvars;
   for (temp=0;temp<nelements_of_obj;temp++) {
     obj[temp] = 0.0;
     vtype[temp] = myvars[temp].vtype;
	 strcpy( varnames[temp], myvars[temp].varname);
   }
   sprintf(searchstr,"myobj");
   index = locatevariablenameinmyvars(searchstr);
   temp = index;
   obj[temp] = 1.0;
}

void dothememoryallocation()
{ 
  int index;
  for (index=0;index<MAXNVARS;index++) {
	  varnames[index] = (char*) malloc( MAXVARIABLESTRINGLENGTH * sizeof(char));
      if (varnames[index]==NULL) { fprintf(stderr,"malloc failure in dothememoryallocation: varnames\n");   exit(-1); }
  }
}

void freethememory()
{
  int index;
  for (index=0;index<MAXNVARS;index++) {
	  free( varnames[index]);
  }
}

void add_constraint_eq14a(int i)
{
   int j;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"cu_%d", i);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   for (j=1;j<=tasks[i].nstages;j++) {
		sprintf(searchstr,"cu_%d_%d", i,j);
		index = locatevariablenameinmyvars(searchstr);
        ind[nelements_of_constr] = index;
        val[nelements_of_constr] = -tasks[i].nsegments_of_stage[j];
		nelements_of_constr = nelements_of_constr + 1;
   }
   constraint_sense = GRB_EQUAL; 
   constraint_rhs = 0.0;
}
void add_constraint_eq14b(int i)
{
   int j;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"etau_%d", i);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   for (j=1;j<=tasks[i].nstages;j++) {
		sprintf(searchstr,"cu_%d_%d", i,j);
		index = locatevariablenameinmyvars(searchstr);
        ind[nelements_of_constr] = index;
        val[nelements_of_constr] = -divandceil(tasks[i].nsegments_of_stage[j],nprocessors);
		nelements_of_constr = nelements_of_constr + 1;
   }
   constraint_sense = GRB_EQUAL; 
   constraint_rhs = 0.0;
}
void add_constraint_eq14c(int i,int j)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"bspu_%d_%d", i,j);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"cu_%d_%d", i,j);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(1/s)*divandfloor(tasks[i].nsegments_of_stage[j],nprocessors);
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_EQUAL; 
   constraint_rhs = 0.0;
}
void add_constraint_eq14d(int i,int j)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"spu_%d_%d", i,j);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"cu_%d_%d", i,j);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(1/s)*divandceil(tasks[i].nsegments_of_stage[j],nprocessors);
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_EQUAL; 
   constraint_rhs = 0.0;
}
void add_constraint_eq15_first_part(int iprime,int qprime,int jprime,int fprime,int k)
{
   int jprimeprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"t_%d_%d_%d_%d_%d", iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1.0;
   nelements_of_constr = nelements_of_constr + 1;

   for (jprimeprime=1;jprimeprime<=jprime;jprimeprime++) {
	   sprintf(searchstr,"spu_%d_%d", iprime,jprimeprime);
       index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = (((double) K)/k);
       nelements_of_constr = nelements_of_constr + 1;
   }

   if (fprime==1) {
     sprintf(searchstr,"bspu_%d_%d", iprime,jprime+1);
     index = locatevariablenameinmyvars(searchstr);
     ind[nelements_of_constr] = index;
     val[nelements_of_constr] = (((double) K)/k);
     nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"wi_%d", k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = (qprime-1)*tasks[iprime].T + tasks[iprime].D + getBIG();  
}
void add_constraint_eq15_second_part(int iprime,int qprime,int jprime,int fprime,int k)
{
   int jprimeprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"t_%d_%d_%d_%d_%d", iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1.0;
   nelements_of_constr = nelements_of_constr + 1;

   for (jprimeprime=1;jprimeprime<=jprime;jprimeprime++) {
	   sprintf(searchstr,"spu_%d_%d", iprime,jprimeprime);
       index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = (((double) K)/k);
       nelements_of_constr = nelements_of_constr + 1;
   }

   if (fprime==1) {
     sprintf(searchstr,"bspu_%d_%d", iprime,jprime+1);
     index = locatevariablenameinmyvars(searchstr);
     ind[nelements_of_constr] = index;
     val[nelements_of_constr] = (((double) K)/k);
     nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"wi_%d", k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = (qprime-1)*tasks[iprime].T + tasks[iprime].D + -getBIG();  
}

void add_constraint_eq16(int i,int iprime,int qprime,int jprime,int fprime,int k)
{
   int q;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"t_%d_%d_%d_%d_%d", iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1.0;
   nelements_of_constr = nelements_of_constr + 1;

   // there it no need to perform iteration for q=0 because the constant becomes zero. So we skip that.
   for (q=1;q<=(P/tasks[i].T);q++) {
	   sprintf(searchstr,"I_%d_%d_%d_%d_%d_%d_%d", i,q,iprime,qprime,jprime,fprime,k);
       index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = -(q*(tasks[i].T));
       nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"r_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -1;
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_EQUAL; 
   constraint_rhs = 0;
}
void add_constraint_eq17(int i,int iprime,int qprime,int jprime,int fprime,int k)
{
   int q;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   for (q=0;q<=(P/tasks[i].T);q++) {
	   sprintf(searchstr,"I_%d_%d_%d_%d_%d_%d_%d", i,q,iprime,qprime,jprime,fprime,k);
       index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = 1;
       nelements_of_constr = nelements_of_constr + 1;
   }

   constraint_sense = GRB_EQUAL; 
   constraint_rhs = 1;
}
void add_constraint_eq18(int i,int iprime,int qprime,int jprime,int fprime,int k)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"r_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = tasks[i].T;
}
void add_constraint_eq19(int i,int q,int iprime,int qprime,int jprime,int fprime,int k)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"aj_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"cu_%d", i);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(q+1);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"I_%d_%d_%d_%d_%d_%d_%d", i,q,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = -getBIG();
}
void add_constraint_eq19b(int i,int q,int iprime,int qprime,int jprime,int fprime,int k)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"aj_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"cu_%d", i);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(q+1);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"I_%d_%d_%d_%d_%d_%d_%d", i,q,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] =  getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs =  getBIG();
}

void add_constraint_eq20(int i,int iprime,int qprime,int jprime,int fprime,int k)
{
   int j;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"wjf_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   for (j=0;j<=tasks[i].nstages-1;j++) {
	   sprintf(searchstr,"wjsf_%d_%d_%d_%d_%d_%d_%d", i,j,iprime,qprime,jprime,fprime,k);
       index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = 1;
       nelements_of_constr = nelements_of_constr + 1;
   }

   for (j=0;j<=tasks[i].nstages-1;j++) {
	   sprintf(searchstr,"wjss_%d_%d_%d_%d_%d_%d_%d", i,j,iprime,qprime,jprime,fprime,k);
       index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = 1;
       nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"wjt_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_EQUAL; 
   constraint_rhs = 1;
}
void add_constraint_eq21(int i,int iprime,int qprime,int jprime,int fprime,int k)
{
   int jprimeprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;
 
   sprintf(searchstr,"r_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = (((double) k)/K);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"wjf_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = (((double) k)/K)*(tasks[i].D) - getBIG();
}
void add_constraint_eq22_first_part(int i,int j,int iprime,int qprime,int jprime,int fprime,int k)
{
   int jprimeprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;
 
   for (jprimeprime=1;jprimeprime<=j;jprimeprime++) {
	   sprintf(searchstr,"spu_%d_%d", i,jprimeprime );
	   index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = 1;
       nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"r_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = (((double) k)/K);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"wjsf_%d_%d_%d_%d_%d_%d_%d", i,j,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = (((double) k)/K)*(tasks[i].D) + getBIG();
}
void add_constraint_eq22_second_part(int i,int j,int iprime,int qprime,int jprime,int fprime,int k)
{
   int jprimeprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;
 
   for (jprimeprime=1;jprimeprime<=j;jprimeprime++) {
	   sprintf(searchstr,"spu_%d_%d", i,jprimeprime );
	   index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = 1;
       nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"bspu_%d_%d", i,j+1 );
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"r_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = (((double) k)/K);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"wjsf_%d_%d_%d_%d_%d_%d_%d", i,j,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = (((double) k)/K)*(tasks[i].D) - getBIG();
}
void add_constraint_eq23_first_part(int i,int j,int iprime,int qprime,int jprime,int fprime,int k)
{
   int jprimeprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;
 
   for (jprimeprime=1;jprimeprime<=j;jprimeprime++) {
	   sprintf(searchstr,"spu_%d_%d", i,jprimeprime );
	   index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = 1;
       nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"bspu_%d_%d", i,j+1 );
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"r_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = (((double) k)/K);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"wjss_%d_%d_%d_%d_%d_%d_%d", i,j,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = (((double) k)/K)*(tasks[i].D) + getBIG();
}
void add_constraint_eq23_second_part(int i,int j,int iprime,int qprime,int jprime,int fprime,int k)
{
   int jprimeprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;
 
   for (jprimeprime=1;jprimeprime<=j+1;jprimeprime++) {
	   sprintf(searchstr,"spu_%d_%d", i,jprimeprime );
	   index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = 1;
       nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"r_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = (((double) k)/K);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"wjss_%d_%d_%d_%d_%d_%d_%d", i,j,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = (((double) k)/K)*(tasks[i].D) - getBIG();
}
void add_constraint_eq24(int i,int iprime,int qprime,int jprime,int fprime,int k)
{
   int jprimeprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;
 
   for (jprimeprime=1;jprimeprime<=tasks[i].nstages;jprimeprime++) {
	   sprintf(searchstr,"spu_%d_%d", i,jprimeprime );
	   index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = 1;
       nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"r_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = (((double) k)/K);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"wjt_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = (((double) k)/K)*(tasks[i].D) + getBIG();
}
void add_constraint_eq25(int i,int iprime,int qprime,int jprime,int fprime,int k)
{
   int jprimeprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;
 
   sprintf(searchstr,"w_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"wjf_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = getBIG();
}
void add_constraint_eq25b(int i,int iprime,int qprime,int jprime,int fprime,int k)
{
   int jprimeprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;
 
   sprintf(searchstr,"w_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"wjf_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = -getBIG();
}

void add_constraint_eq26(int i,int j,int iprime,int qprime,int jprime,int fprime,int k)
{
   int jprimeprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;
 
   sprintf(searchstr,"w_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   for (jprimeprime=1;jprimeprime<=j;jprimeprime++) {
	   sprintf(searchstr,"cu_%d_%d", i,jprimeprime );
	   index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = -tasks[i].nsegments_of_stage[jprimeprime];
       nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"r_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = (((double) k)/K)*nprocessors*s;
   nelements_of_constr = nelements_of_constr + 1;

   for (jprimeprime=1;jprimeprime<=j;jprimeprime++) {
	   sprintf(searchstr,"spu_%d_%d", i,jprimeprime );
	   index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = nprocessors * s;
       nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"wjsf_%d_%d_%d_%d_%d_%d_%d", i,j,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = (((double) k)/K)*(tasks[i].D)*nprocessors*s + getBIG();  
}
void add_constraint_eq26b(int i,int j,int iprime,int qprime,int jprime,int fprime,int k)
{
   int jprimeprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;
 
   sprintf(searchstr,"w_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   for (jprimeprime=1;jprimeprime<=j;jprimeprime++) {
	   sprintf(searchstr,"cu_%d_%d", i,jprimeprime );
	   index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = -tasks[i].nsegments_of_stage[jprimeprime];
       nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"r_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = (((double) k)/K)*nprocessors*s;
   nelements_of_constr = nelements_of_constr + 1;

   for (jprimeprime=1;jprimeprime<=j;jprimeprime++) {
	   sprintf(searchstr,"spu_%d_%d", i,jprimeprime );
	   index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = nprocessors * s;
       nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"wjsf_%d_%d_%d_%d_%d_%d_%d", i,j,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = (((double) k)/K)*(tasks[i].D)*nprocessors*s - getBIG();  
}

void add_constraint_eq27(int i,int j,int iprime,int qprime,int jprime,int fprime,int k)
{
   int jprimeprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;
 
   sprintf(searchstr,"w_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   for (jprimeprime=1;jprimeprime<=j;jprimeprime++) {
	   sprintf(searchstr,"cu_%d_%d", i,jprimeprime );
	   index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = -tasks[i].nsegments_of_stage[jprimeprime];
       nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"bspu_%d_%d", i,j+1 );
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = ((tasks[i].nsegments_of_stage[j] % nprocessors) * s) - nprocessors * s;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"r_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = (((double) k)/K)*((tasks[i].nsegments_of_stage[j] % nprocessors) * s); 
   nelements_of_constr = nelements_of_constr + 1;

   for (jprimeprime=1;jprimeprime<=j;jprimeprime++) {
	   sprintf(searchstr,"spu_%d_%d", i,jprimeprime );
	   index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = ((tasks[i].nsegments_of_stage[j] % nprocessors) * s);
       nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"wjss_%d_%d_%d_%d_%d_%d_%d", i,j,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = (((double) k)/K)*((tasks[i].nsegments_of_stage[j] % nprocessors) * s)*(tasks[i].D) + getBIG();  
}
void add_constraint_eq27b(int i,int j,int iprime,int qprime,int jprime,int fprime,int k)
{
   int jprimeprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;
 
   sprintf(searchstr,"w_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   for (jprimeprime=1;jprimeprime<=j;jprimeprime++) {
	   sprintf(searchstr,"cu_%d_%d", i,jprimeprime );
	   index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = -tasks[i].nsegments_of_stage[jprimeprime];
       nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"bspu_%d_%d", i,j+1 );
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = ((tasks[i].nsegments_of_stage[j] % nprocessors) * s) - nprocessors * s;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"r_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = (((double) k)/K)*((tasks[i].nsegments_of_stage[j] % nprocessors) * s); 
   nelements_of_constr = nelements_of_constr + 1;

   for (jprimeprime=1;jprimeprime<=j;jprimeprime++) {
	   sprintf(searchstr,"spu_%d_%d", i,jprimeprime );
	   index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = ((tasks[i].nsegments_of_stage[j] % nprocessors) * s);
       nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"wjss_%d_%d_%d_%d_%d_%d_%d", i,j,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = (((double) k)/K)*((tasks[i].nsegments_of_stage[j] % nprocessors) * s)*(tasks[i].D) - getBIG();  
}

void add_constraint_eq28(int i,int iprime,int qprime,int jprime,int fprime,int k)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;
 
   sprintf(searchstr,"w_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"cu_%d", i );
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"wjt_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = getBIG();  
}
void add_constraint_eq28b(int i,int iprime,int qprime,int jprime,int fprime,int k)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;
 
   sprintf(searchstr,"w_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"cu_%d", i );
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"wjt_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = -getBIG();  
}

void add_constraint_eq29(int iprime,int qprime,int jprime,int fprime,int k)
{
   int i;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   for (i=1;i<=ntasks;i++) {
     sprintf(searchstr,"aj_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
     index = locatevariablenameinmyvars(searchstr);
     ind[nelements_of_constr] = index;
     val[nelements_of_constr] = 1.0;
     nelements_of_constr = nelements_of_constr + 1;
   }

   for (i=1;i<=ntasks;i++) {
     sprintf(searchstr,"w_%d_%d_%d_%d_%d_%d", i,iprime,qprime,jprime,fprime,k);
     index = locatevariablenameinmyvars(searchstr);
     ind[nelements_of_constr] = index;
     val[nelements_of_constr] = -1;
     nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"t_%d_%d_%d_%d_%d", iprime,qprime,jprime,fprime,k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(nprocessors - (nprocessors-1)*(((double) k)/K))*s;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"wi_%d", k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = getBIG();    
}
void add_constraint_eq30(int k)
{
   int i;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   for (i=1;i<=ntasks;i++) {
     sprintf(searchstr,"cu_%d", i);
     index = locatevariablenameinmyvars(searchstr);
     ind[nelements_of_constr] = index;
     val[nelements_of_constr] = 1.0/tasks[i].T;
     nelements_of_constr = nelements_of_constr + 1;
   }

   sprintf(searchstr,"wi_%d", k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIGfor_util_constraints();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = (nprocessors - (nprocessors-1)*(((double) k)/K))*s+getBIGfor_util_constraints();
}
void add_constraint_eq31(int i,int k)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"etau_%d", i);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"wi_%d", k);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = (((double) k)/K)*s*tasks[i].D+getBIG();
}

void add_constraint_eq32()
{
   int k;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   for (k=1;k<=K;k++) {
     sprintf(searchstr,"wi_%d", k);
     index = locatevariablenameinmyvars(searchstr);
     ind[nelements_of_constr] = index;
     val[nelements_of_constr] = 1.0;
     nelements_of_constr = nelements_of_constr + 1;
   }

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = 1;
}
void add_constraint_eq38(int i,int j,int g,int b)
{
   int p; int h;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   for (p=0;p<=tasks[i].memoryaccessesdescription[j].npages-1;p++) {
     for (h=0;h<=H-1;h++) {
       sprintf(searchstr,"o_%d_%d_%d_%d_%d_%d", i,j,g,p,h,b);
       index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = -tasks[i].memoryaccessesdescription[j].MA[p]*(1.0/SCALINGFACTORNACCESSES);
       nelements_of_constr = nelements_of_constr + 1;
	 }
   }
   constraint_sense = GRB_EQUAL; 
   constraint_rhs = 0;  
}

void add_constraint_eq39(int i,int iprime,int jprime,int gprime,int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"mmb_%d_%d_%d_%d_%d", i,iprime,jprime,gprime,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mb_%d_%d_%d_%d", iprime,jprime,gprime,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(ceil( tasks[i].D/tasks[iprime].T)+1);
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_EQUAL; 
   constraint_rhs = 0;
}
void add_constraint_eq40(int i,int j,int g,int b)
{
   int iprime; int jprime; int gprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   for (iprime=1;iprime<=ntasks;iprime++) {
     for (jprime=1;jprime<=tasks[iprime].nstages;jprime++) {
       for (gprime=1;gprime<=tasks[iprime].nsegments_of_stage[jprime];gprime++) {
		 if (((iprime==i) && (jprime==j) && (gprime!=g)) || (iprime!=i)) { 
           sprintf(searchstr,"mmb_%d_%d_%d_%d_%d", i,iprime,jprime,gprime,b);
           index = locatevariablenameinmyvars(searchstr);
           ind[nelements_of_constr] = index;
           val[nelements_of_constr] = -1;
           nelements_of_constr = nelements_of_constr + 1;
		 }
	   }
	 }
   }

   constraint_sense = GRB_EQUAL; 
   constraint_rhs = 0;
}

void add_constraint_eq41(int i,int j,int g,int p)
{
   int h; int b;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   for (h=0;h<=H-1;h++) {
     for (b=0;b<=B-1;b++) {
       sprintf(searchstr,"o_%d_%d_%d_%d_%d_%d", i,j,g,p,h,b);
       index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = 1;
       nelements_of_constr = nelements_of_constr + 1;
	 }
   }

   constraint_sense = GRB_EQUAL; 
   constraint_rhs = 1;
}

void add_constraint_eq42_for_first_pass(int h,int b)
{
   int i; int j; int g; int p;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   for (i=1;i<=ntasks;i++) {
     for (j=1;j<=tasks[i].nstages;j++) {
       for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
         for (p=0;p<=tasks[i].memoryaccessesdescription[j].npages-1;p++) {
           sprintf(searchstr,"o_%d_%d_%d_%d_%d_%d", i,j,g,p,h,b);
           index = locatevariablenameinmyvars(searchstr);
           ind[nelements_of_constr] = index;
           val[nelements_of_constr] = 1.0/computegroupsize(i,j,g,p);
           nelements_of_constr = nelements_of_constr + 1;
	     }
	   }
	 }
   }

   sprintf(searchstr,"ino_%d_%d", h,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1.0;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"loadfactorofcells");
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -CAP;
   nelements_of_constr = nelements_of_constr + 1;
	
   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = 0;
}

void add_constraint_eq42(int h,int b)
{
   int i; int j; int g; int p;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   for (i=1;i<=ntasks;i++) {
     for (j=1;j<=tasks[i].nstages;j++) {
       for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
         for (p=0;p<=tasks[i].memoryaccessesdescription[j].npages-1;p++) {
           sprintf(searchstr,"o_%d_%d_%d_%d_%d_%d", i,j,g,p,h,b);
           index = locatevariablenameinmyvars(searchstr);
           ind[nelements_of_constr] = index;
           val[nelements_of_constr] = 1.0/computegroupsize(i,j,g,p);
           nelements_of_constr = nelements_of_constr + 1;
	     }
	   }
	 }
   }

   sprintf(searchstr,"ino_%d_%d", h,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1.0;
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = CAP;
}
void add_constraint_eq43()
{
   int h; int b;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   for (h=0;h<=H-1;h++) {
     for (b=0;b<=B-1;b++) {
       sprintf(searchstr,"ino_%d_%d", h,b);
       index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = 1.0;
       nelements_of_constr = nelements_of_constr + 1;
     }
   }

   constraint_sense = GRB_EQUAL; 
   constraint_rhs = INO;;
}

void add_constraint_eq44(int i,int j,int g,int h)
{
   int p; int b;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   for (p=0;p<=tasks[i].memoryaccessesdescription[j].npages-1;p++) {
     for (b=0;b<=B-1;b++) {
           sprintf(searchstr,"o_%d_%d_%d_%d_%d_%d", i,j,g,p,h,b);
           index = locatevariablenameinmyvars(searchstr);
           ind[nelements_of_constr] = index;
           val[nelements_of_constr] = 1;
           nelements_of_constr = nelements_of_constr + 1;
	 }
   }

   sprintf(searchstr,"x_%d_%d_%d_%d", i,j,g,h);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -1;
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = 0;
}
void add_constraint_eq45(int i,int j,int g,int h)
{
   int p; int b;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   for (p=0;p<=tasks[i].memoryaccessesdescription[j].npages-1;p++) {
     for (b=0;b<=B-1;b++) {
           sprintf(searchstr,"o_%d_%d_%d_%d_%d_%d", i,j,g,p,h,b);
           index = locatevariablenameinmyvars(searchstr);
           ind[nelements_of_constr] = index;
           val[nelements_of_constr] = 1;
           nelements_of_constr = nelements_of_constr + 1;
	 }
   }

   sprintf(searchstr,"x_%d_%d_%d_%d", i,j,g,h);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIGfor_x_and_o_for_a_given_i_and_j(i,j);
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = 0;
}
void add_constraint_eq46(int i,int j,int g,int iprime,int jprime,int gprime,int h)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"x_%d_%d_%d_%d", i,j,g,h);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"x_%d_%d_%d_%d", iprime,jprime,gprime,h);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = 1;
}
void add_constraint_eq47(int i,int j,int g)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"cm_%d_%d_%d", i,j,g);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"cu_%d_%d", i,j);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -1;
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = 0;  
}
void add_constraint_eq48(int i,int j)
{
   int g;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
     sprintf(searchstr,"se_%d_%d_%d", i,j,g);
     index = locatevariablenameinmyvars(searchstr);
     ind[nelements_of_constr] = index;
     val[nelements_of_constr] = 1;
     nelements_of_constr = nelements_of_constr + 1;
   }

   constraint_sense = GRB_EQUAL; 
   constraint_rhs = 1;    
}
void add_constraint_eq49(int i,int j,int g)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"cu_%d_%d", i,j);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"cm_%d_%d_%d", i,j,g);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"se_%d_%d_%d", i,j,g);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = getBIG();  
}
void add_constraint_eq50(int iprime,int jprime,int gprime,int pprime,int iprimeprime,int jprimeprime,int gprimeprime,int pprimeprime,int h,int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"o_%d_%d_%d_%d_%d_%d", iprime,jprime,gprime,pprime,h,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"o_%d_%d_%d_%d_%d_%d", iprimeprime,jprimeprime,gprimeprime,pprimeprime,h,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -1;
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_EQUAL; 
   constraint_rhs = 0;    
}

void add_constraint_eq51(int i,int j,int g)
{
   int b;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"cm_%d_%d_%d", i,j,g);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   for (b=0;b<=B-1;b++) {
     sprintf(searchstr,"coat_%d_%d_%d_%d", i,j,g,b);
     index = locatevariablenameinmyvars(searchstr);
     ind[nelements_of_constr] = index;
     val[nelements_of_constr] = -s*(1/MBCF)*SCALINGFACTORNACCESSES;
     nelements_of_constr = nelements_of_constr + 1;
   
     sprintf(searchstr,"oao_%d_%d_%d_%d", i,j,g,b);
     index = locatevariablenameinmyvars(searchstr);
     ind[nelements_of_constr] = index;
     val[nelements_of_constr] = -s*Linter*(1/MBCF)*SCALINGFACTORNACCESSES;
     nelements_of_constr = nelements_of_constr + 1;
   }
   constraint_sense = GRB_EQUAL; 
   constraint_rhs = tasks[i].exec_of_stage[j];
}

void add_constraint_eq52(int i,int j,int g, int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"bc1_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc2_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc3_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc4_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_EQUAL; 
   constraint_rhs = 1;
}

void add_constraint_eq53(int i,int j,int g, int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getLIMIT1();
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc1_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = getBIG();
}
void add_constraint_eq54_first_part(int i,int j,int g, int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getLIMIT1();
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc2_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = getBIG();
}
void add_constraint_eq54_second_part(int i,int j,int g, int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = (getLIMIT1()+1);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc2_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = -getBIG();
}
void add_constraint_eq55_first_part(int i,int j,int g,int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getLIMIT1()+1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc3_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = getBIG();  
}
void add_constraint_eq55_second_part(int i,int j,int g,int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getLIMIT2();
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc3_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = -getBIG();  
}
void add_constraint_eq56(int i,int j,int g,int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getLIMIT2();
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc4_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = getBIG();  
}
void add_constraint_eq57(int i,int j,int g,int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"coat_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(Lconf+Linter);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc1_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = -getBIG();    
}
void add_constraint_eq57b(int i,int j,int g,int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"coat_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(Lconf+Linter);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc1_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = getBIG();    
}

void add_constraint_eq58(int i,int j,int g,int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"coat_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getLIMIT1()*(Lconf+Linter)+getLIMIT1()*(wl+bl/2+twr);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(wl+bl/2+twr);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc2_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = -getBIG();    
}

void add_constraint_eq58b(int i,int j,int g,int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"coat_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getLIMIT1()*(Lconf+Linter)+getLIMIT1()*(wl+bl/2+twr);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(wl+bl/2+twr);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc2_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] =  getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs =  getBIG();    
}

void add_constraint_eq59(int i,int j,int g,int b)
{
  int index;
  char searchstr[200];
  nelements_of_constr = 0;

  sprintf(searchstr,"coat_%d_%d_%d_%d", i,j,g,b);
  index = locatevariablenameinmyvars(searchstr);
  ind[nelements_of_constr] = index;
  val[nelements_of_constr] = 1;
  nelements_of_constr = nelements_of_constr + 1;

  sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
  index = locatevariablenameinmyvars(searchstr);
  ind[nelements_of_constr] = index;
  val[nelements_of_constr] = -getLIMIT1()*(Lconf+Linter)-(wl+bl/2+twr)+(getLIMIT1()+1)*(wl+bl/2+twr+cl)/2.0;
  nelements_of_constr = nelements_of_constr + 1;

  sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,b);
  index = locatevariablenameinmyvars(searchstr);
  ind[nelements_of_constr] = index;
  val[nelements_of_constr] = -(wl+bl/2+twr+cl)/2.0;
  nelements_of_constr = nelements_of_constr + 1;

  sprintf(searchstr,"bc3_%d_%d_%d_%d", i,j,g,b);
  index = locatevariablenameinmyvars(searchstr);
  ind[nelements_of_constr] = index;
  val[nelements_of_constr] = -getBIG();
  nelements_of_constr = nelements_of_constr + 1;

  constraint_sense = GRB_GREATER_EQUAL; 
  constraint_rhs = -getBIG();    
}
void add_constraint_eq59b(int i,int j,int g,int b)
{
  int index;
  char searchstr[200];
  nelements_of_constr = 0;

  sprintf(searchstr,"coat_%d_%d_%d_%d", i,j,g,b);
  index = locatevariablenameinmyvars(searchstr);
  ind[nelements_of_constr] = index;
  val[nelements_of_constr] = 1;
  nelements_of_constr = nelements_of_constr + 1;

  sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
  index = locatevariablenameinmyvars(searchstr);
  ind[nelements_of_constr] = index;
  val[nelements_of_constr] = -getLIMIT1()*(Lconf+Linter)-(wl+bl/2+twr)+(getLIMIT1()+1)*(wl+bl/2+twr+cl)/2.0;
  nelements_of_constr = nelements_of_constr + 1;

  sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,b);
  index = locatevariablenameinmyvars(searchstr);
  ind[nelements_of_constr] = index;
  val[nelements_of_constr] = -(wl+bl/2+twr+cl)/2.0;
  nelements_of_constr = nelements_of_constr + 1;

  sprintf(searchstr,"bc3_%d_%d_%d_%d", i,j,g,b);
  index = locatevariablenameinmyvars(searchstr);
  ind[nelements_of_constr] = index;
  val[nelements_of_constr] =  getBIG();
  nelements_of_constr = nelements_of_constr + 1;

  constraint_sense = GRB_LESS_EQUAL; 
  constraint_rhs =  getBIG();    
}

void add_constraint_eq60(int i,int j,int g,int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"coat_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(getLIMIT1()*(Lconf+Linter)+getLconhitNre());
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc4_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = -getBIG();    
}
void add_constraint_eq60b(int i,int j,int g,int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"coat_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(getLIMIT1()*(Lconf+Linter)+getLconhitNre());
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc4_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] =  getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs =  getBIG();    
}
void add_constraint_eq61(int i,int j,int g,int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"oat_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc4_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = 0;    
}
void add_constraint_eq61b(int i,int j,int g,int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"oat_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc4_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = 0;    
}

void add_constraint_eq62(int i,int j,int g,int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"oat_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getLIMIT2();
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc4_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = -getBIG();    
}
void add_constraint_eq62b(int i,int j,int g,int b)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"oat_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getLIMIT2();
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bc4_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] =  getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs =  getBIG();
}
void add_constraint_eq63(int i,int j,int g,int b)
{
   int bprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   for (bprime=0;bprime<=B-1;bprime++) {
     if (bprime!=b) {
       sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,bprime);
       index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = 1;
       nelements_of_constr = nelements_of_constr + 1;
     }
   }

   sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(B-1);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"oat_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(B-1);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bu_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = 0;    
}

void add_constraint_eq64(int i,int j,int g,int b)
{
   int bprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   for (bprime=0;bprime<=B-1;bprime++) {
     if (bprime!=b) {
       sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,bprime);
       index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = 1;
       nelements_of_constr = nelements_of_constr + 1;
     }
   }

   sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(B-1);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"oat_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(B-1);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bu_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = -getBIG();    
}
void add_constraint_eq65(int i,int j,int g,int b)
{
   int bprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"oao_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   for (bprime=0;bprime<=B-1;bprime++) {
     if (bprime!=b) {
       sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,bprime);
       index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = -1;
       nelements_of_constr = nelements_of_constr + 1;
     }
   }

   sprintf(searchstr,"bu_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = 0;    
}
void add_constraint_eq65b(int i,int j,int g,int b)
{
   int bprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"oao_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   for (bprime=0;bprime<=B-1;bprime++) {
     if (bprime!=b) {
       sprintf(searchstr,"mmbo_%d_%d_%d_%d", i,j,g,bprime);
       index = locatevariablenameinmyvars(searchstr);
       ind[nelements_of_constr] = index;
       val[nelements_of_constr] = -1;
       nelements_of_constr = nelements_of_constr + 1;
     }
   }

   sprintf(searchstr,"bu_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = 0;    
}

void add_constraint_eq66(int i,int j,int g,int b)
{
   int bprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"oao_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(B-1);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"oat_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(B-1);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bu_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_GREATER_EQUAL; 
   constraint_rhs = -getBIG();    
}
void add_constraint_eq66b(int i,int j,int g,int b)
{
   int bprime;
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"oao_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"mb_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(B-1);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"oat_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = -(B-1);
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"bu_%d_%d_%d_%d", i,j,g,b);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] =  getBIG();
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs =  getBIG();    
}

int getsegmentcounter( int i, int g)
{
  int iprime;
  int jprime;
  int sumsofar;
  int largeststage;
  sumsofar = 0;
  for (iprime=1;iprime<=i-1;iprime++) {
	largeststage = -1;
    for (jprime=1;jprime<=tasks[iprime].nstages;jprime++) {
		if (largeststage<tasks[iprime].nsegments_of_stage[jprime]) {
		  largeststage = tasks[iprime].nsegments_of_stage[jprime];
		}
	}
    sumsofar = sumsofar + largeststage;
  }
  sumsofar = sumsofar + g - 1;
  return sumsofar;
}

int getmaximumsegmentcounter()
{
  int iprime;
  int jprime;
  int sumsofar;
  int largeststage;
  sumsofar = 0;
  for (iprime=1;iprime<=ntasks;iprime++) {
	largeststage = -1;
    for (jprime=1;jprime<=tasks[iprime].nstages;jprime++) {
		if (largeststage<tasks[iprime].nsegments_of_stage[jprime]) {
		  largeststage = tasks[iprime].nsegments_of_stage[jprime];
		}
	}
    sumsofar = sumsofar + largeststage;
  }
  sumsofar = sumsofar - 1;
  return sumsofar;
}

void createmstfilefromsol(char* mipfnsol,char* mipfnmst)
{
  char vn[1000]; int vv;
  char tempstr[1000];
  FILE* fin; FILE* fout;
  fin = fopen( mipfnsol, "r");
  fout = fopen( mipfnmst, "w");

  if (fgets( tempstr, 1000, fin)==NULL) {
	  printf("Error 1 in createmstfilefromsol\n"); exit(-1);
  }
  if (fgets( tempstr, 1000, fin)==NULL) {
	  printf("Error 2 in createmstfilefromsol\n"); exit(-1);
  }
  if (fgets( tempstr, 1000, fin)==NULL) {
	  printf("Error 3 in createmstfilefromsol\n"); exit(-1);
  }

  fputs("# MIP start\n", fout);
  while (fgets( tempstr, 1000, fin)!=NULL) {
	  sscanf(tempstr,"%s %d", vn, &vv); 
	  if (vv==1) {
	    fputs(tempstr, fout);
	  }
  }

  fclose( fin);
  fclose( fout);
}

void addaconstraint(int index, double the_value)
{
   nelements_of_constr = 0;

   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_EQUAL; 
   constraint_rhs = the_value;

#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) { printf("Error in addaconstraint\n"); exit(-1); }
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif
}

void myGRBread( char* mipfnmst )
{
  char tempstr[1000];
  FILE* fin; FILE* fout;
  char vn[1000]; int vv;
  double the_value;
  int index;
  fin = fopen( mipfnmst, "r");

  if (fgets( tempstr, 1000, fin)==NULL) {
	  printf("Error 1 in myGRBread\n"); exit(-1);
  }

  while (fgets( tempstr, 1000, fin)!=NULL) {
	  sscanf(tempstr,"%s %d", vn, &vv); 
      index = locatevariablenameinmyvars(vn);
	  the_value = vv;
	  printf("debug printout. varname=%s index=%d value=%lf\n", vn, index, the_value); 
	  addaconstraint(index,the_value);
  }

  fclose( fin);
}

#if CALLGUROBITHROUGHAPI

void addconstraintsfromfirstsolution()
{
   int temp;
   for (temp=0;temp<nelements_of_obj;temp++) {
		if (strncmp(varnames[temp],"o_",2)==0)	{
                  if (sol[temp]==1.0) {
                    addaconstraint( temp, 1.0);
                  } else {
                    if (sol[temp]==0.0) {
                      addaconstraint( temp, 0.0);
                    } else {
                      if (sol[temp]<0.00001) {
                        printf("Something is a little strange but not necessarily wrong in addconstraintsfromfirstsolution. Place 1. temp=%d sol[temp]=%lf\n", temp, sol[temp]);
                      } else {
                        if (sol[temp]>1-0.00001) {
                          printf("Something is a little strange but not necessarily wrong in addconstraintsfromfirstsolution. Place 2. temp=%d sol[temp]=%lf\n", temp, sol[temp]);
                        } else {
                          printf("Something is wrong in addconstraintsfromfirstsolution. Place 3. temp=%d sol[temp]=%lf\n", temp, sol[temp]); exit(-1);
                        }
                      }
                    }
                  }
		}
		if (strncmp(varnames[temp],"x_",2)==0)	{
                  if (sol[temp]==1.0) {
                    addaconstraint( temp, 1.0);
                  } else {
                    if (sol[temp]==0.0) {
                      addaconstraint( temp, 0.0);
                    } else {
                      if (sol[temp]<0.00001) {
                        printf("Something is a little strange but not necessarily wrong in addconstraintsfromfirstsolution. Place 4. temp=%d sol[temp]=%lf\n", temp, sol[temp]);
                      } else {
                        if (sol[temp]>1-0.00001) {
                          printf("Something is a little strange but not necessarily wrong in addconstraintsfromfirstsolution. Place 5. temp=%d sol[temp]=%lf\n", temp, sol[temp]);
                        } else {
                          printf("Something is wrong in addconstraintsfromfirstsolution. Place 6. temp=%d sol[temp]=%lf\n", temp, sol[temp]); exit(-1);
                        }
                      }
                    }
                  }
		}
		if (strncmp(varnames[temp],"ino_",4)==0)	{
          addaconstraint( temp, sol[temp]);				
		}
   }
}

#else

void addconstraintsfromfirstsolution_onlpfile(char* fn_with_solution)
{
  char tempstr[200];
  char tempvarname[200];
  double tempvalue;
  int temp;
  FILE* f;
  f = fopen( fn_with_solution, "r");
  fgets( tempstr, 200,f );
  while (tempstr[0]=='#') {
    fgets( tempstr, 200, f);
  }
  // now we have a string that does not start with #
  do {
    sscanf( tempstr, "%s %lf", tempvarname, &tempvalue);
    temp = locatevariablenameinmyvars(tempvarname);
    sol[temp] = tempvalue;
  } while (fgets( tempstr, 200, f)!=NULL);
  fclose( f);

   // code below does the same thing as addconstraintsfromfirstsolution
   for (temp=0;temp<nelements_of_obj;temp++) {
		if (strncmp(varnames[temp],"o_",2)==0)	{
                  if (sol[temp]==1.0) {
                    addaconstraint( temp, 1.0);
                  } else {
                    if (sol[temp]==0.0) {
                      addaconstraint( temp, 0.0);
                    } else {
                      if (sol[temp]<0.00001) {
                        printf("Something is a little strange but not necessarily wrong in addconstraintsfromfirstsolution. Place 1. temp=%d sol[temp]=%lf\n", temp, sol[temp]);
                      } else {
                        if (sol[temp]>1-0.00001) {
                          printf("Something is a little strange but not necessarily wrong in addconstraintsfromfirstsolution. Place 2. temp=%d sol[temp]=%lf\n", temp, sol[temp]);
                        } else {
                          printf("Something is wrong in addconstraintsfromfirstsolution. Place 3. temp=%d sol[temp]=%lf\n", temp, sol[temp]); exit(-1);
                        }
                      }
                    }
                  }
		}
		if (strncmp(varnames[temp],"x_",2)==0)	{
                  if (sol[temp]==1.0) {
                    addaconstraint( temp, 1.0);
                  } else {
                    if (sol[temp]==0.0) {
                      addaconstraint( temp, 0.0);
                    } else {
                      if (sol[temp]<0.00001) {
                        printf("Something is a little strange but not necessarily wrong in addconstraintsfromfirstsolution. Place 4. temp=%d sol[temp]=%lf\n", temp, sol[temp]);
                      } else {
                        if (sol[temp]>1-0.00001) {
                          printf("Something is a little strange but not necessarily wrong in addconstraintsfromfirstsolution. Place 5. temp=%d sol[temp]=%lf\n", temp, sol[temp]);
                        } else {
                          printf("Something is wrong in addconstraintsfromfirstsolution. Place 6. temp=%d sol[temp]=%lf\n", temp, sol[temp]); exit(-1);
                        }
                      }
                    }
                  }
		}
		if (strncmp(varnames[temp],"ino_",4)==0)	{
          addaconstraint( temp, sol[temp]);				
		}
   }

}

#endif

void setwik()
{
   int temp;
   for (temp=0;temp<nelements_of_obj;temp++) {
		if (strncmp(varnames[temp],"wi_10",4)==0)	{ addaconstraint( temp, 0.0); }	
		if (strncmp(varnames[temp],"wi_2",4)==0)	{ addaconstraint( temp, 0.0); }	
		if (strncmp(varnames[temp],"wi_3",4)==0)	{ addaconstraint( temp, 0.0); }	
		if (strncmp(varnames[temp],"wi_4",4)==0)	{ addaconstraint( temp, 0.0); }	
		if (strncmp(varnames[temp],"wi_5",4)==0)	{ addaconstraint( temp, 0.0); }	
		if (strncmp(varnames[temp],"wi_6",4)==0)	{ addaconstraint( temp, 0.0); }	
		if (strncmp(varnames[temp],"wi_7",4)==0)	{ addaconstraint( temp, 0.0); }	
		if (strncmp(varnames[temp],"wi_8",4)==0)	{ addaconstraint( temp, 0.0); }	
		if (strncmp(varnames[temp],"wi_9",4)==0)	{ addaconstraint( temp, 0.0); }	
		if (strncmp(varnames[temp],"wi_10",5)==0)	{ addaconstraint( temp, 1.0); }	
		if (strncmp(varnames[temp],"wi_11",5)==0)	{ addaconstraint( temp, 0.0); }	
		if (strncmp(varnames[temp],"wi_12",5)==0)	{ addaconstraint( temp, 0.0); }	
		if (strncmp(varnames[temp],"wi_13",5)==0)	{ addaconstraint( temp, 0.0); }	
		if (strncmp(varnames[temp],"wi_14",5)==0)	{ addaconstraint( temp, 0.0); }	
		if (strncmp(varnames[temp],"wi_15",5)==0)	{ addaconstraint( temp, 0.0); }	
		if (strncmp(varnames[temp],"wi_16",5)==0)	{ addaconstraint( temp, 0.0); }	
		if (strncmp(varnames[temp],"wi_17",5)==0)	{ addaconstraint( temp, 0.0); }	
		if (strncmp(varnames[temp],"wi_18",5)==0)	{ addaconstraint( temp, 0.0); }	
		if (strncmp(varnames[temp],"wi_19",5)==0)	{ addaconstraint( temp, 0.0); }	
		if (strncmp(varnames[temp],"wi_20",5)==0)	{ addaconstraint( temp, 0.0); } 
  }
}

#if CALLGUROBITHROUGHAPI

void setcoefficientformyobjtozero_in_objectivefunction()
{
  char searchstr[200]; int index;
  sprintf(searchstr,"myobj");
  index = locatevariablenameinmyvars(searchstr);
  GRBsetdblattrelement( model, GRB_DBL_ATTR_OBJ, index, 0.0);
}

#else

void setcoefficientformyobjtozero_in_objectivefunction_throughpythonfile()
{
  fprintf( gurobithroughcommandlinepyfile, "m.setObjective( 0 )\n" );
}

#endif

void writetomemorymappingfile( char* fn)
{
  FILE* f;
  int i; int j; int g; int p; int h; int b;
  char searchstr[200];
  int index;
  f = fopen( fn, "w");
  
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
        for (p=0;p<=tasks[i].memoryaccessesdescription[j].npages-1;p++) {
          for (h=0;h<=H-1;h++) {
            for (b=0;b<=B-1;b++) {
              sprintf(searchstr,"o_%d_%d_%d_%d_%d_%d", i,j,g,p,h,b);
              index = locatevariablenameinmyvars(searchstr);
              if (sol[index]==1.0) {
                fprintf(f,"%d %d %d %d %d %d\n", i,j,g,p,h,b);
              } else {
                if (sol[index]==0.0) {
                  ;
                } else {
                  printf("Error in writetomemorymappingfile\n");
                  exit( -1);
                }
              }
            }
	  }
	}
      }
    }
  }
  fclose( f);
}

void getmminternal( int i, int j, int g, int p, int* pfound, int* pthe_found_h, int* pthe_found_b)
{
  char searchstr[200];
  int index;
  int h; int b;
          *pfound = 0;
          for (h=0;h<=H-1;h++) {
            for (b=0;b<=B-1;b++) {
              sprintf(searchstr,"o_%d_%d_%d_%d_%d_%d", i,j,g,p,h,b);
              index = locatevariablenameinmyvars(searchstr);
              if (sol[index]==1.0) {
                *pfound = 1;
                *pthe_found_h = h;
                *pthe_found_b = b;
              } else {
                if (sol[index]==0.0) {
                  ;
                } else {
                  printf("Error in writetomemorymappingfile\n");
                  exit( -1);
                }
              }
            }
	  }
}

int getmmbc( int i, int j, int g, int p)
{
  int found; int the_found_h; int the_found_b;
  getmminternal( i, j, g, p, &found, &the_found_h, &the_found_b);
  if (found) {
    return the_found_b;
  } else {
    printf("Error in getmm_bc\n");
    exit( -1);
  }
}

int getmmcc( int i, int j, int g, int p)
{
  int found; int the_found_h; int the_found_b;
  getmminternal( i, j, g, p, &found, &the_found_h, &the_found_b);
  if (found) {
    return the_found_h;
  } else {
    printf("Error in getmm_cc\n");
    exit( -1);
  }
}

int getntasks()
{
  return ntasks;
}
int getnstages(int i)
{
  return tasks[i].nstages;
}
int getnsegments(int i,int j)
{
  return tasks[i].nsegments_of_stage[j];
}
int getnpages(int i,int j,int g)
{
  return tasks[i].memoryaccessesdescription[j].npages;
}

int getdegree(int i)
{
  int j; int temp;
  temp = -1;
  for (j=1;j<=tasks[i].nstages;j++) {
    temp = maxint2( temp, tasks[i].nsegments_of_stage[j] );
  }
  if (temp==-1) { printf("Error in getdegree with i=%d\n", i); }
  return temp;
}

void recalculate_o_to_satisfy_sharedframes()
{
  char searchstr[200]; char searchstr1[200]; char searchstr2[200];
  int index; int index1; int index2;
  int i;      int j;      int g;      int p;
  int iprime; int jprime; int gprime; int pprime;
  int iowner; int jowner; int gowner; int powner;
  int hprime; int bprime;
  int h;      int b;
  int v;
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
        for (p=0;p<=tasks[i].memoryaccessesdescription[j].npages-1;p++) {
          computegroupsize(i,j,g,p); // the purpose of this is not to compute size; the purpose of this call is that it computes visited as a side effect
          // we choose as the owner the "smallest one" in the group in which i,j,g,p belong
          iowner = i; jowner = j; gowner = g; powner = p;
          for (iprime=1;iprime<=ntasks;iprime++) {
            for (jprime=1;jprime<=tasks[iprime].nstages;jprime++) {
              for (gprime=1;gprime<=tasks[iprime].nsegments_of_stage[jprime];gprime++) {
                for (pprime=0;pprime<=tasks[iprime].memoryaccessesdescription[jprime].npages-1;pprime++) {
                  if (isvisited(iprime,jprime,gprime,pprime)) {
                    if (  (iprime<iowner)                                                ||
                         ((iprime==iowner) && (jprime<jowner))                            ||
                         ((iprime==iowner) && (jprime==jowner) && (gprime<gowner))         ||
                         ((iprime==iowner) && (jprime==jowner) && (gprime==gowner) && (pprime<powner))
                       ) {
                                     iowner = iprime; jowner = jprime; gowner = gprime; powner = pprime;
                         }                    
                  }
                }
              }
            }
          }
          for (h=0;h<=H-1;h++) {
            for (b=0;b<=B-1;b++) {
              sprintf(searchstr1,"o_%d_%d_%d_%d_%d_%d", i,j,g,p, h, b);
              index1 = locatevariablenameinmyvars(searchstr1);
              sprintf(searchstr2,"o_%d_%d_%d_%d_%d_%d", iowner,jowner,gowner,powner, h, b);
              index2 = locatevariablenameinmyvars(searchstr2);
              addaconstraint( index1, sol[ index2]);
            }
          }                     
        }
      }
    }
  }
}

double getvalue_from_solution_file(char* searchstr, char* fn)
{
  char tempstr[1000];
  char local_varname[1000];
  double local_value;
  double found_value;
  FILE* f;
  if (searchstr==NULL) {
    printf("Error in getvalue_from_solution_file. Searchstring is NULL\n"); exit(-1);
  } else {
    if (fn==NULL) {
      printf("Error in getvalue_from_solution_file. Filename is NULL\n"); exit(-1);
    } else {
      f = fopen( fn, "r");
      fgets(tempstr,1000,f);
      fgets(tempstr,1000,f);
      while (fgets(tempstr,1000,f)!=NULL) {
        sscanf(tempstr,"%s %lf", local_varname, &local_value);
        if (strcmp(searchstr, local_varname)==0) {
          found_value = local_value;
        }
      }
      fclose( f);
    }
  }
  return found_value;
}

struct mybufferofovalues_struct {
  char varname[30];
  double value;
};

int mybufferofovalues_nelements;
#define MAXNELEMENTSINMYBUFFEROFVALUES 1000000
struct mybufferofovalues_struct mybufferofovalues[MAXNELEMENTSINMYBUFFEROFVALUES];
void mybufferofovalues_setup()
{
  char tempstr[1000];
  char local_varname[1000];
  double local_value;
  FILE* f;
  mybufferofovalues_nelements = 0;
  f = fopen( "temp.sol", "r");
  if (f==NULL) { printf("Error in mybufferofovalues_setup. Could not open file."); exit(-1); } 
  fgets(tempstr,1000,f);
  fgets(tempstr,1000,f);
  while (fgets(tempstr,1000,f)!=NULL) {
    sscanf(tempstr,"%s %lf", local_varname, &local_value);
    if (strncmp(local_varname,"o_",2)==0) {
      strcpy( mybufferofovalues[ mybufferofovalues_nelements].varname, local_varname);
      mybufferofovalues[ mybufferofovalues_nelements].value = local_value;
      mybufferofovalues_nelements++;
      if (mybufferofovalues_nelements>MAXNELEMENTSINMYBUFFEROFVALUES) { printf("Error in mybufferofovalues_setup. Too many elements."); exit(-1); }
    }
  }
  fclose( f);
}
double mybufferofovalues_getvalue( char* searchstr)
{
  int index; int found; double v;
  found = 0;
  for (index=0;index<mybufferofovalues_nelements;index++) {
    if (strcmp( mybufferofovalues[ index].varname, searchstr)==0) {
      v = mybufferofovalues[ index].value;
      found = 1;
    }
  }
  if (found==0) { printf("Error in mybufferofovalues_getvalue\n"); exit(-1); }
  return v;
}

void add_constraints_recalculate_o_to_satisfy_sharedframes()
{
  char searchstr1[200]; char searchstr2[200]; int index1;
  int i;      int j;      int g;      int p;
  int iprime; int jprime; int gprime; int pprime;
  int iowner; int jowner; int gowner; int powner;
  int h;      int b;   double v;
  mybufferofovalues_setup();
  for (i=1;i<=ntasks;i++) {
    for (j=1;j<=tasks[i].nstages;j++) {
      for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
        for (p=0;p<=tasks[i].memoryaccessesdescription[j].npages-1;p++) {
          computegroupsize(i,j,g,p); // the purpose of this is not to compute size; the purpose of this call is that it computes visited as a side effect
          // we choose as the owner the "smallest one" in the group in which i,j,g,p belong
          iowner = i; jowner = j; gowner = g; powner = p;
          for (iprime=1;iprime<=ntasks;iprime++) {
            for (jprime=1;jprime<=tasks[iprime].nstages;jprime++) {
              for (gprime=1;gprime<=tasks[iprime].nsegments_of_stage[jprime];gprime++) {
                for (pprime=0;pprime<=tasks[iprime].memoryaccessesdescription[jprime].npages-1;pprime++) {
                  if (isvisited(iprime,jprime,gprime,pprime)) {
                    if (  (iprime<iowner)                                                ||
                         ((iprime==iowner) && (jprime<jowner))                            ||
                         ((iprime==iowner) && (jprime==jowner) && (gprime<gowner))         ||
                         ((iprime==iowner) && (jprime==jowner) && (gprime==gowner) && (pprime<powner))
                       ) {
                                     iowner = iprime; jowner = jprime; gowner = gprime; powner = pprime;
                         }                    
                  }
                }
              }
            }
          }
          for (h=0;h<=H-1;h++) {
            for (b=0;b<=B-1;b++) {
              sprintf(searchstr1,"o_%d_%d_%d_%d_%d_%d", i,j,g,p, h, b);
              index1 = locatevariablenameinmyvars(searchstr1);
              sprintf(searchstr2,"o_%d_%d_%d_%d_%d_%d", iowner,jowner,gowner,powner, h, b);
              v = mybufferofovalues_getvalue( searchstr2);
              if (strcmp(searchstr1, searchstr2)==0) {
                printf("Within add_constraints_recalculate_o_to_satisfy_sharedframes                    : %d %d %d %d   %d %d %d %d   %d %d    %lf\n", i,j,g,p, iowner,jowner,gowner,powner,   h,b, v);
              } else {
                printf("Within add_constraints_recalculate_o_to_satisfy_sharedframes, assigned to other : %d %d %d %d   %d %d %d %d   %d %d    %lf\n", i,j,g,p, iowner,jowner,gowner,powner,   h,b, v);
              }
              addaconstraint( index1, v);
            }
          }                     
        }
      }
    }
  }
}


void addalltheconstraintsofeq50()
{
   int iprime;
   int jprime;
   int gprime;
   int pprime;
   int iprimeprime;
   int jprimeprime;
   int gprimeprime;
   int pprimeprime;
   int h; int b;

     for (iprime=1;iprime<=ntasks;iprime++) {
       for (jprime=1;jprime<=tasks[iprime].nstages;jprime++) {
         for (gprime=1;gprime<=tasks[iprime].nsegments_of_stage[jprime];gprime++) {
           for (pprime=0;pprime<=tasks[iprime].memoryaccessesdescription[jprime].npages-1;pprime++) {
             for (iprimeprime=1;iprimeprime<=ntasks;iprimeprime++) {
               for (jprimeprime=1;jprimeprime<=tasks[iprimeprime].nstages;jprimeprime++) {
                 for (gprimeprime=1;gprimeprime<=tasks[iprimeprime].nsegments_of_stage[jprimeprime];gprimeprime++) {
                   for (pprimeprime=0;pprimeprime<=tasks[iprimeprime].memoryaccessesdescription[jprimeprime].npages-1;pprimeprime++) {
                     for (h=0;h<=H-1;h++) {
                       for (b=0;b<=B-1;b++) {
                         if (is_in_sharedframes(iprime,jprime,gprime,pprime,iprimeprime,jprimeprime,gprimeprime,pprimeprime)) {
                           add_constraint_eq50(iprime,jprime,gprime,pprime,iprimeprime,jprimeprime,gprimeprime,pprimeprime,h,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) { printf("Error in addalltheconstraintsofeq50\n"); exit(-1); }
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
					     }
		               }
		             }
		           }
		         }
		       }
		     }
		   }
	     }
	   }
     }
}

void add_constraint_to_break_symmetry_a(int iprime,int jprime,int gprime,int hprime,int iprimeprime,int jprimeprime,int gprimeprime,int hprimeprime)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"x_%d_%d_%d_%d", iprime,jprime,gprime,hprime);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"x_%d_%d_%d_%d", iprimeprime,jprimeprime,gprimeprime,hprimeprime);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = 1;
}

void add_constraint_to_break_symmetry_b(int iprime,int jprime,int gprime,int pprime,int hprime,int bprime,int iprimeprime,int jprimeprime,int gprimeprime,int pprimeprime,int hprimeprime,int bprimeprime)
{
   int index;
   char searchstr[200];
   nelements_of_constr = 0;

   sprintf(searchstr,"o_%d_%d_%d_%d_%d_%d", iprime,jprime,gprime,pprime,hprime,bprime);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   sprintf(searchstr,"o_%d_%d_%d_%d_%d_%d", iprimeprime,jprimeprime,gprimeprime,pprimeprime,hprimeprime,bprimeprime);
   index = locatevariablenameinmyvars(searchstr);
   ind[nelements_of_constr] = index;
   val[nelements_of_constr] = 1;
   nelements_of_constr = nelements_of_constr + 1;

   constraint_sense = GRB_LESS_EQUAL; 
   constraint_rhs = 1;
}

void addalltheconstraints_to_break_symmetry()
{
   int iprime;
   int jprime;
   int gprime;
   int pprime;
   int hprime;
   int bprime;

   int iprimeprime;
   int jprimeprime;
   int gprimeprime;
   int pprimeprime;
   int hprimeprime;
   int bprimeprime;

     for (iprime=1;iprime<=ntasks;iprime++) {
       for (jprime=1;jprime<=tasks[iprime].nstages;jprime++) {
         for (gprime=1;gprime<=tasks[iprime].nsegments_of_stage[jprime];gprime++) {
             for (hprime=0;hprime<=H-1;hprime++) {
                 for (iprimeprime=1;iprimeprime<=ntasks;iprimeprime++) {
                   for (jprimeprime=1;jprimeprime<=tasks[iprimeprime].nstages;jprimeprime++) {
                     for (gprimeprime=1;gprimeprime<=tasks[iprimeprime].nsegments_of_stage[jprimeprime];gprimeprime++) {
                         for (hprimeprime=0;hprimeprime<=H-1;hprimeprime++) {
                             if ((iprime<iprimeprime) && (hprime>=hprimeprime)) { 
                               add_constraint_to_break_symmetry_a(iprime,jprime,gprime,hprime,iprimeprime,jprimeprime,gprimeprime,hprimeprime);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) { printf("Error in addalltheconstraintsofeq50\n"); exit(-1); }
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		             }
		         }
		     }
		   }
	         }
	     }
         }
       }
     }
}


double gettwopowerabove(double tempinput)
{
  double lb; double ub;
  lb = 1.0;
  while (tempinput<lb) { lb = lb/2; }
  ub = lb;
  while (tempinput>ub) { ub = ub*2; }
  return ub;
}

void computeSCALINGFACTORNACCESSES()
{
  double t; double t2; double t3; double t4;
  SCALINGFACTORNACCESSES = 1;
  if (getBIGparteq69()>0) {
     t  = getBIGparteq70();
     t2 = getBIGparteq71();
     t3 = t/t2;
     t4 = gettwopowerabove(t3);
     SCALINGFACTORNACCESSES = t4;
   } else {
     SCALINGFACTORNACCESSES = 8388608;
   }
}

#if CALLGUROBITHROUGHAPI

#else
void write_the_end_of_lp_file( FILE* f)
{
   int tempindex;
   fprintf( f, "Binaries\n");
   for (tempindex=0;tempindex<nvars_in_myvars;tempindex++) {
     if (myvars[tempindex].vtype==GRB_BINARY) { fprintf( f, " %s\n", myvars[tempindex].varname); }
   }
   fprintf( f, "End\n");
}
#endif

void go_through_file_and_remove_variables_that_are_not_used_in_first_phase_of_method3(char* fn)
{
  FILE* fr; FILE* fw;
  char tempstr[200];
  char* mybuf;
  int reached_section_with_variables;
  int should_be_removed;
  sprintf( tempstr, "cp %s q.txt", fn);
  system( tempstr);
  fr = fopen("q.txt","r");
  fw = fopen(fn,"w");
  mybuf = (char*) malloc( sizeof(char)*100000000);
  if (mybuf==NULL) {
    printf("Error in go_through_file_and_remove_variables_that_are_not_used_in_first_phase_of_method3\n");
    exit(-1);
  }
  reached_section_with_variables = 0;
  while (fgets( mybuf, 100000000, fr)!=NULL) {
    if (strstr( mybuf, "bin")!=NULL) { reached_section_with_variables = 1; }
    if (strstr( mybuf, "Binaries")!=NULL) { reached_section_with_variables = 1; }
    if (strstr( mybuf, "gen")!=NULL) { reached_section_with_variables = 1; }
    if (strstr( mybuf, "Generals")!=NULL) { reached_section_with_variables = 1; }
    if (reached_section_with_variables) {
      should_be_removed = 0;
      // the binary variables that should be removed
      if (strstr( mybuf, "I_")!=NULL)    { should_be_removed = 1; }
      if (strstr( mybuf, "wjf_")!=NULL)  { should_be_removed = 1; }
      if (strstr( mybuf, "wjsf_")!=NULL) { should_be_removed = 1; }
      if (strstr( mybuf, "wjss_")!=NULL) { should_be_removed = 1; }
      if (strstr( mybuf, "wjt_")!=NULL)  { should_be_removed = 1; }
      if (strstr( mybuf, "wi_")!=NULL)    { should_be_removed = 1; }
      // the real variables that should be removed
      if (strstr( mybuf, "t_")!=NULL)    { should_be_removed = 1; }
      if (strstr( mybuf, "r_")!=NULL)    { should_be_removed = 1; }
      if (strstr( mybuf, "aj_")!=NULL)   { should_be_removed = 1; }
      if (strstr( mybuf, "w_")!=NULL)    { should_be_removed = 1; }
    } else {
      should_be_removed = 0;
    }
    if (!should_be_removed) {
      fprintf( fw, "%s", mybuf );
    }
  }
  fclose( fr);
  fclose( fw);
}

void go_through_file_and_remove_settimelimit_in_file(char* fn)
{
  FILE* fr; FILE* fw;
  char tempstr[200];
  char* mybuf;
  int should_be_removed;
  sprintf( tempstr, "cp %s q.txt", fn);
  system( tempstr);
  fr = fopen("q.txt","r");
  fw = fopen(fn,"w");
  mybuf = (char*) malloc( sizeof(char)*100000000);
  if (mybuf==NULL) { printf("Error in go_through_file_and_remove_variables_that_are_not_used_in_first_phase_of_method3\n"); exit(-1); }
  while (fgets( mybuf, 100000000, fr)!=NULL) {
    should_be_removed = 0;
    if (strstr( mybuf, "TIMELIMIT")!=NULL)    { should_be_removed = 1; }
    if (!should_be_removed) {
      fprintf( fw, "%s", mybuf );
    }
  }
  fclose( fr);
  fclose( fw);
}

void go_through_file_and_remove_myobj_in_file(char* fn)
{
  FILE* fr; FILE* fw;
  char tempstr[200];
  char* mybuf;
  int should_be_removed;
  sprintf( tempstr, "cp %s q.txt", fn);
  system( tempstr);
  fr = fopen("q.txt","r");
  fw = fopen(fn,"w");
  mybuf = (char*) malloc( sizeof(char)*100000000);
  if (mybuf==NULL) { printf("Error in go_through_file_and_remove_variables_that_are_not_used_in_first_phase_of_method3\n"); exit(-1); }
  while (fgets( mybuf, 100000000, fr)!=NULL) {
    should_be_removed = 0;
    if (strstr( mybuf, "myobj")!=NULL)    { should_be_removed = 1; }
    if (!should_be_removed) {
      fprintf( fw, "%s", mybuf );
    } else {
      fprintf( fw, "\n" );
    }
  }
  fclose( fr);
  fclose( fw);
}

int fileexistsandisnotempty(char* fn)
{
  FILE* f; char mycharacter; int nret;
  int fileexists;
  f = fopen(fn,"r");
  if (f!=NULL) {
    nret = fscanf( f,"%c", &mycharacter);
    if (nret==1) {
      fileexists = 1;
    } else {
      fileexists = 0;
    }
    fclose( f); 
  } else {
    fileexists = 0;
  }
  return fileexists;
}

void perform_schedulability_analysis_internal(int* feas, double* value)
{
   int tempindex;
   char tempstr[200];
   int i; int j;

   int iprime;
   int qprime;
   int jprime;
   int fprime;
   int k;
   int q;

   int g; int gprime;
   int h; int b;
   int p;

   int pprime;
   int bprime;
   int iprimeprime;
   int jprimeprime;
   int gprimeprime;
   int pprimeprime;

   char miplogfn[200]; char mipfn[200]; char mipfnlp[200]; char mipfnsol[200];
   char mipfnmst[200];
   char mipfnmemorymappingtouse[200];

   int old_optimstatus;
   double old_objval;

   int localcounter;
   int localsolcount;

   compute_derived_parameters(); // we have already call this function when using setsystem1 but it does not hurt to call it again. 

   allocate_variables_needed_for_interacting_with_Gurobi(); // this allocates memory for vectors

   computeSCALINGFACTORNACCESSES();

   *feas = 0;

   dothememoryallocation(); // this allocates memory for strings

   counterforILPsolver = counterforILPsolver + 1;
   sprintf(miplogfn,"mip%d.log", counterforILPsolver); 
   sprintf(mipfn,"mip%d", counterforILPsolver); 
   sprintf(mipfnlp,"mip%d.lp", counterforILPsolver); 
   sprintf(mipfnsol,"mip%d.sol", counterforILPsolver); 
   sprintf(mipfnmemorymappingtouse,"mipmemorymappingtouse%d.txt", counterforILPsolver); 

   myGRB_INT_PAR_MIPFOCUS  = 1;
   myGRB_INT_PAR_AGGREGATE = 0;
   myGRB_DBL_PAR_FEASIBILITYTOL  = 0.000000001;
   myGRB_DBL_PAR_INTFEASTOL = 0.000000001;
   myGRB_DBL_PAR_MARKOWITZTOL  = 0.5;
   myGRB_INT_PAR_QUAD = 1;
   myGRB_INT_PAR_NUMERICFOCUS  = 3;
   myGRB_DBL_PAR_HEURISTICS = 0.5;
   myGRB_DBL_PAR_FEASRELAXBIGM = 1000000000000*100;

#if CALLGUROBITHROUGHAPI
   error = GRBloadenv( &env, miplogfn);
   if (error || env == NULL) {
     fprintf(stderr, "Error: could not create environment\n");   
	 exit(0);
   }
   error = GRBsetintparam( env, GRB_INT_PAR_MIPFOCUS, myGRB_INT_PAR_MIPFOCUS);
   if (error) goto QUIT;
   error = GRBsetintparam( env, GRB_INT_PAR_AGGREGATE, myGRB_INT_PAR_AGGREGATE);
   if (error) goto QUIT;
   error = GRBsetdblparam( env, GRB_DBL_PAR_FEASIBILITYTOL, myGRB_DBL_PAR_FEASIBILITYTOL);
   if (error) goto QUIT;
   error = GRBsetdblparam( env, GRB_DBL_PAR_INTFEASTOL, myGRB_DBL_PAR_INTFEASTOL);
   if (error) goto QUIT;
   error = GRBsetdblparam( env, GRB_DBL_PAR_MARKOWITZTOL, myGRB_DBL_PAR_MARKOWITZTOL);
   if (error) goto QUIT;
   error = GRBsetintparam( env, GRB_INT_PAR_QUAD, myGRB_INT_PAR_QUAD);
   if (error) goto QUIT;
   error = GRBsetintparam( env, GRB_INT_PAR_NUMERICFOCUS, myGRB_INT_PAR_NUMERICFOCUS);
   if (error) goto QUIT;
   error = GRBsetdblparam( env, GRB_DBL_PAR_HEURISTICS, myGRB_DBL_PAR_HEURISTICS);
   if (error) goto QUIT;
   error = GRBsetdblparam( env, GRB_DBL_PAR_FEASRELAXBIGM, myGRB_DBL_PAR_FEASRELAXBIGM );
   if (error) goto QUIT;

   if (method==3) {
     error = GRBsetdblparam( env, GRB_DBL_PAR_TIMELIMIT, GUROBITIMEOUTPARAMETER );
     if (error) goto QUIT;
   }

   error = GRBnewmodel( env, &model, mipfn, 0, NULL, NULL, NULL, NULL, NULL );
   if (error) goto QUIT;
#else
   sprintf( gurobithroughcommandlinelpfilename, "commandline%d.lp", counterforILPsolver);
   sprintf( gurobithroughcommandlinepyfilename, "commandline%d.py", counterforILPsolver);
   gurobithroughcommandlinelpfile = fopen( gurobithroughcommandlinelpfilename, "w");
#endif
   create_tables_with_variable_names();
   fillobj_for_objective_function();
#if CALLGUROBITHROUGHAPI
   error = GRBaddvars( model, nelements_of_obj, 0, NULL, NULL, NULL, obj, NULL, NULL, vtype, varnames);
   if (error) goto QUIT;
   error = GRBsetintattr( model, GRB_INT_ATTR_MODELSENSE, GRB_MINIMIZE);
   if (error) goto QUIT;

   error = GRBupdatemodel( model);
   if (error) goto QUIT;
#else
   fprintf( gurobithroughcommandlinelpfile, "Minimize\n");
   if (method<=2) {
     fprintf( gurobithroughcommandlinelpfile, "\n");
   } else {
     if (method==3) {
       fprintf( gurobithroughcommandlinelpfile, "  myobj\n");
     } else {
       printf("Unknown method\n");
       exit(-1);
     }
   }
   fprintf( gurobithroughcommandlinelpfile, "Subject To\n");
#endif

   for (i=1;i<=ntasks;i++) {
     for (j=1;j<=tasks[i].nstages;j++) {
       for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
         for (p=0;p<=tasks[i].memoryaccessesdescription[j].npages-1;p++) {
           add_constraint_eq41(i,j,g,p);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		 }
	   }
	 }
   }

     for (h=0;h<=H-1;h++) {
       for (b=0;b<=B-1;b++) {
         add_constraint_eq42_for_first_pass(h,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
       }
     }

     for (h=0;h<=H-1;h++) {
       for (b=0;b<=B-1;b++) {
         add_constraint_eq42(h,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	   }
     }

   add_constraint_eq43();
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    

   for (i=1;i<=ntasks;i++) {
     for (j=1;j<=tasks[i].nstages;j++) {
       for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
         for (h=0;h<=H-1;h++) {
           add_constraint_eq44(i,j,g,h);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		 }
	   }
	 }
   }
   for (i=1;i<=ntasks;i++) {
     for (j=1;j<=tasks[i].nstages;j++) {
       for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
         for (h=0;h<=H-1;h++) {
           add_constraint_eq45(i,j,g,h);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		 }
	   }
	 }
   }
   for (i=1;i<=ntasks;i++) {
     for (j=1;j<=tasks[i].nstages;j++) {
       for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
         for (iprime=1;iprime<=ntasks;iprime++) {
           for (jprime=1;jprime<=tasks[iprime].nstages;jprime++) {
             for (gprime=1;gprime<=tasks[iprime].nsegments_of_stage[jprime];gprime++) {
               for (h=0;h<=H-1;h++) {
				 if (((i==iprime) && (j==jprime) && (g<gprime)) || (i<iprime)) {
                   add_constraint_eq46(i,j,g,iprime,jprime,gprime,h);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
				 }
		       }
		     }
		   }
		 }
	   }
	 }
   }
   addalltheconstraintsofeq50();

     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           for (b=0;b<=B-1;b++) {
               add_constraint_eq38(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		   }
	     }
	   }
     }

     for (i=1;i<=ntasks;i++) {
       for (iprime=1;iprime<=ntasks;iprime++) {
         for (jprime=1;jprime<=tasks[iprime].nstages;jprime++) {
           for (gprime=1;gprime<=tasks[iprime].nsegments_of_stage[jprime];gprime++) {
             for (b=0;b<=B-1;b++) {
               add_constraint_eq39(i,iprime,jprime,gprime,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		     }
		   }
	     }
	   }
     }

     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           for (b=0;b<=B-1;b++) {
             add_constraint_eq40(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	       }
	     }
	   }
     }

     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           for (b=0;b<=B-1;b++) {
             add_constraint_eq52(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	   }
	 }
       }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           for (b=0;b<=B-1;b++) {
             add_constraint_eq53(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	   }
	 }
       }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           for (b=0;b<=B-1;b++) {
             add_constraint_eq54_first_part(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
             add_constraint_eq54_second_part(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	   }
	 }
       }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           for (b=0;b<=B-1;b++) {
             add_constraint_eq55_first_part(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
             add_constraint_eq55_second_part(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	   }
	 }
       }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           for (b=0;b<=B-1;b++) {
             add_constraint_eq56(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
           }	       	   
	 }
       }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           for (b=0;b<=B-1;b++) {
             add_constraint_eq57(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
             add_constraint_eq57b(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	   }
	 }
       }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           for (b=0;b<=B-1;b++) {
             add_constraint_eq58(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
             add_constraint_eq58b(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	   }
	 }
       }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           for (b=0;b<=B-1;b++) {
             add_constraint_eq59(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
             add_constraint_eq59b(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	   }
	 }
       }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           for (b=0;b<=B-1;b++) {
             add_constraint_eq60(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
             add_constraint_eq60b(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
           }
	 }
       }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           for (b=0;b<=B-1;b++) {
             add_constraint_eq61(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
             add_constraint_eq61b(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    

	   }
	 }
       }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           for (b=0;b<=B-1;b++) {
             add_constraint_eq62(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
             add_constraint_eq62b(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
           }
	 }
       }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           for (b=0;b<=B-1;b++) {
             add_constraint_eq63(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	   }
	 }
       }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           for (b=0;b<=B-1;b++) {
             add_constraint_eq64(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	   }
	 }
       }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           for (b=0;b<=B-1;b++) {
             add_constraint_eq65(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
             add_constraint_eq65b(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	   }
	 }
       }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           for (b=0;b<=B-1;b++) {
             add_constraint_eq66(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
             add_constraint_eq66b(i,j,g,b);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	   }
	 }
       }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           add_constraint_eq47(i,j,g);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	     }
	   }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         add_constraint_eq48(i,j);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	   }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           add_constraint_eq49(i,j,g);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	     }
	   }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
         for (g=1;g<=tasks[i].nsegments_of_stage[j];g++) {
           add_constraint_eq51(i,j,g);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
         }
       }
     }
     for (i=1;i<=ntasks;i++) {
	   add_constraint_eq14a(i);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
     }
     for (i=1;i<=ntasks;i++) {
	     add_constraint_eq14b(i);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
	     add_constraint_eq14c(i,j);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	   }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=1;j<=tasks[i].nstages;j++) {
  	     add_constraint_eq14d(i,j);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	   }
     }
   addconstraintutilconsideringcont();
   for (i=1;i<=ntasks;i++) { addconstraintloadofdeadline(i); }
   addconstraintmyobj();

   if (method>=2) {
     addalltheconstraints_to_break_symmetry();
   }

#if CALLGUROBITHROUGHAPI
   if (method==3) {
     error = GRBupdatemodel( model);
     if (error) goto QUIT;

     error = GRBwrite( model, "temp_intermediate_results_method4.lp");

     error = GRBoptimize(model);
     if (error) goto QUIT;
     error = GRBupdatemodel( model);
     if (error) goto QUIT;
     error = GRBgetintattr( model, GRB_INT_ATTR_STATUS, &optimstatus);
     if (error) goto QUIT;
     error = GRBgetdblattr( model, GRB_DBL_ATTR_OBJVAL, &objval);
     if (error) goto QUIT;
     if (optimstatus!=GRB_OPTIMAL) {       
       error = GRBgetintattr( model, GRB_INT_ATTR_SOLCOUNT, &localsolcount);
       if (error) goto QUIT;
       while (localsolcount==0) {
         error = GRBoptimize(model);
         if (error) goto QUIT;
         error = GRBupdatemodel( model);
         if (error) goto QUIT;
         error = GRBgetintattr( model, GRB_INT_ATTR_STATUS, &optimstatus);
         if (error) goto QUIT;
         error = GRBgetdblattr( model, GRB_DBL_ATTR_OBJVAL, &objval);
         if (error) goto QUIT;
         error = GRBgetintattr( model, GRB_INT_ATTR_SOLCOUNT, &localsolcount);
         if (error) goto QUIT;
       }
       old_optimstatus = optimstatus;    
       old_objval      = objval;    
       error = GRBoptimize(model);
       if (error) goto QUIT;
       error = GRBupdatemodel( model);
       if (error) goto QUIT;
       error = GRBgetintattr( model, GRB_INT_ATTR_STATUS, &optimstatus);
       if (error) goto QUIT;
       error = GRBgetdblattr( model, GRB_DBL_ATTR_OBJVAL, &objval);
       if (error) goto QUIT;
       while ( (optimstatus!=GRB_OPTIMAL) && (objval<old_objval) ) {
         old_optimstatus = optimstatus;    
         old_objval      = objval;    
         error = GRBoptimize(model);
         if (error) goto QUIT;
         error = GRBupdatemodel( model);
         if (error) goto QUIT;
         error = GRBgetintattr( model, GRB_INT_ATTR_STATUS, &optimstatus);
         if (error) goto QUIT;
         error = GRBgetdblattr( model, GRB_DBL_ATTR_OBJVAL, &objval);
         if (error) goto QUIT;
       }
     }
     // now we have a feasible solution and we know that: (optimstatus==GRB_OPTIMAL) || (objval>=old_objval)
     // so we do not need to continue with optimization to find a good memory allocation

     error = GRBsetdblparam( env, GRB_DBL_PAR_TIMELIMIT, GRB_INFINITY);
     if (error) goto QUIT;

     error = GRBupdatemodel( model);
     if (error) goto QUIT;
     GRBwrite( model, "temp_intermediate_results_method4.sol" );

     error = GRBgetdblattrarray( model, GRB_DBL_ATTR_X, 0, nelements_of_obj, sol);
     if (error) goto QUIT;
     addconstraintsfromfirstsolution();
   }
   setcoefficientformyobjtozero_in_objectivefunction();
   error = GRBupdatemodel( model);
   if (error) goto QUIT;
#else
   if (method==3) {
     fclose( gurobithroughcommandlinelpfile);

     my_sleep( 5);
     
     sprintf( tempstr, "cp %s firstphase.lp", gurobithroughcommandlinelpfilename);
     system( tempstr);

     FILE* f;
     f = fopen("firstphase.lp","a");
     write_the_end_of_lp_file( f);
     fclose( f);

     my_sleep( 5);
     go_through_file_and_remove_variables_that_are_not_used_in_first_phase_of_method3("firstphase.lp");
     my_sleep( 5);

     gurobithroughcommandlinepyfile  = fopen( "firstphase.py",  "w"); // this is writing for append at the end of the file
     fprintf( gurobithroughcommandlinepyfile, "from gurobipy import *\n");
     fprintf( gurobithroughcommandlinepyfile, "m = read('firstphase.lp')\n");
     fprintf( gurobithroughcommandlinepyfile, "m.setParam('MIPFOCUS',%d)\n", myGRB_INT_PAR_MIPFOCUS );
     fprintf( gurobithroughcommandlinepyfile, "m.setParam('AGGREGATE',%d)\n", myGRB_INT_PAR_AGGREGATE );
     fprintf( gurobithroughcommandlinepyfile, "m.setParam('FEASIBILITYTOL',%25.15lf)\n", myGRB_DBL_PAR_FEASIBILITYTOL );
     fprintf( gurobithroughcommandlinepyfile, "m.setParam('INTFEASTOL',%25.15lf)\n", myGRB_DBL_PAR_INTFEASTOL  );
     fprintf( gurobithroughcommandlinepyfile, "m.setParam('MARKOWITZTOL',%25.15lf)\n", myGRB_DBL_PAR_MARKOWITZTOL  );
     fprintf( gurobithroughcommandlinepyfile, "m.setParam('QUAD',%d)\n", myGRB_INT_PAR_QUAD );
     fprintf( gurobithroughcommandlinepyfile, "m.setParam('NUMERICFOCUS',%d)\n", myGRB_INT_PAR_NUMERICFOCUS );
     fprintf( gurobithroughcommandlinepyfile, "m.setParam('HEURISTICS',%25.15lf)\n", myGRB_DBL_PAR_HEURISTICS );
     fprintf( gurobithroughcommandlinepyfile, "m.setParam('FEASRELAXBIGM',%25.15lf)\n", myGRB_DBL_PAR_FEASRELAXBIGM );
     fprintf( gurobithroughcommandlinepyfile, "m.setParam('TIMELIMIT',%25.15lf)\n", GUROBITIMEOUTPARAMETER );
     fprintf( gurobithroughcommandlinepyfile, "m.optimize()\n");
     fprintf( gurobithroughcommandlinepyfile, "m.update()\n");
     fprintf( gurobithroughcommandlinepyfile, "if m.status != GRB.status.OPTIMAL:\n");
     fprintf( gurobithroughcommandlinepyfile, "  while (m.solCount==0):\n");
     fprintf( gurobithroughcommandlinepyfile, "    m.optimize()\n");
     fprintf( gurobithroughcommandlinepyfile, "    m.update()\n");
     fprintf( gurobithroughcommandlinepyfile, "  old_optimstatus = m.status\n");
     fprintf( gurobithroughcommandlinepyfile, "  old_objval      = m.objVal\n");
     fprintf( gurobithroughcommandlinepyfile, "  m.optimize()\n");
     fprintf( gurobithroughcommandlinepyfile, "  m.update()\n");
     fprintf( gurobithroughcommandlinepyfile, "  while ( (m.status!=GRB.status.OPTIMAL) and (m.objVal<old_objval) ):\n");
     fprintf( gurobithroughcommandlinepyfile, "    old_optimstatus = m.status\n");
     fprintf( gurobithroughcommandlinepyfile, "    old_objval      = m.objVal\n");
     fprintf( gurobithroughcommandlinepyfile, "    m.optimize()\n");
     fprintf( gurobithroughcommandlinepyfile, "    m.update()\n");
     fprintf( gurobithroughcommandlinepyfile, "m.write('firstphase.sol')\n");
     fprintf( gurobithroughcommandlinepyfile, "exit()\n");
     fclose( gurobithroughcommandlinepyfile);

     #if COMPILEWIN32 || COMPILEMSVS
      sprintf( commandstringwithscript, "gurobi.bat firstphase.py");
     #else 
      sprintf( commandstringwithscript, "gurobi.sh firstphase.py");
     #endif
     system(commandstringwithscript);
     
     my_sleep(1);

     gurobithroughcommandlinelpfile = fopen( gurobithroughcommandlinelpfilename, "a");    // these are already open, we open so that we can write at the end
     addconstraintsfromfirstsolution_onlpfile( "firstphase.sol");   
   }
#endif

     for (iprime=1;iprime<=ntasks;iprime++) {
       for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
         for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
           for (fprime=0;fprime<=1;fprime++) {
             for (k=1;k<=K;k++) {
               add_constraint_eq15_first_part(iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
               add_constraint_eq15_second_part(iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		     }
		   }
	     }
	   }
     }
     for (i=1;i<=ntasks;i++) {
       for (iprime=1;iprime<=ntasks;iprime++) {
         for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
           for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
             for (fprime=0;fprime<=1;fprime++) {
               for (k=1;k<=K;k++) {
                   add_constraint_eq16(i,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	  	       }
		     }
		   }
	     }
	   }
     }
     for (i=1;i<=ntasks;i++) {
       for (iprime=1;iprime<=ntasks;iprime++) {
         for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
           for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
             for (fprime=0;fprime<=1;fprime++) {
               for (k=1;k<=K;k++) {
                   add_constraint_eq17(i,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		       }
		     }
		   }
	     }
	   }
     }
     for (i=1;i<=ntasks;i++) {
       for (iprime=1;iprime<=ntasks;iprime++) {
         for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
           for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
             for (fprime=0;fprime<=1;fprime++) {
               for (k=1;k<=K;k++) {
                   add_constraint_eq18(i,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		       }
		     }
		   }
	     }
	   }
     }
     for (i=1;i<=ntasks;i++) {
       for (q=0;q<=(P/tasks[i].T);q++) {
         for (iprime=1;iprime<=ntasks;iprime++) {
           for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
             for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
               for (fprime=0;fprime<=1;fprime++) {
                 for (k=1;k<=K;k++) {
                   add_constraint_eq19(i,q,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
                   add_constraint_eq19b(i,q,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		         }
		       }
		     }
		   }
	     }
	   }
     }
     for (i=1;i<=ntasks;i++) {
       for (iprime=1;iprime<=ntasks;iprime++) {
         for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
           for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
             for (fprime=0;fprime<=1;fprime++) {
               for (k=1;k<=K;k++) {
                   add_constraint_eq20(i,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		       }
		     }
		   }
	     }
	   }
     }
     for (i=1;i<=ntasks;i++) {
       for (iprime=1;iprime<=ntasks;iprime++) {
         for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
           for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
             for (fprime=0;fprime<=1;fprime++) {
               for (k=1;k<=K;k++) {
                 add_constraint_eq21(i,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		       }
		     }
		   }
	     }
	   }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=0;j<=tasks[i].nstages-1;j++) {
         for (iprime=1;iprime<=ntasks;iprime++) {
           for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
             for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
               for (fprime=0;fprime<=1;fprime++) {
                 for (k=1;k<=K;k++) {
	               add_constraint_eq22_first_part(i,j,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	               add_constraint_eq22_second_part(i,j,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		         }
		       }
		     }
		   }
	     }
	   }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=0;j<=tasks[i].nstages-1;j++) {
         for (iprime=1;iprime<=ntasks;iprime++) {
           for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
             for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
               for (fprime=0;fprime<=1;fprime++) {
                 for (k=1;k<=K;k++) {
                   add_constraint_eq23_first_part(i,j,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
                   add_constraint_eq23_second_part(i,j,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		         }
		       }
		     }
		   }
	     }
	   }
     }
     for (i=1;i<=ntasks;i++) {
       for (iprime=1;iprime<=ntasks;iprime++) {
         for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
           for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
             for (fprime=0;fprime<=1;fprime++) {
               for (k=1;k<=K;k++) {
                 add_constraint_eq24(i,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		       }
		     }
		   }
	     }
	   }
     }
     for (i=1;i<=ntasks;i++) {
       for (iprime=1;iprime<=ntasks;iprime++) {
         for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
           for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
             for (fprime=0;fprime<=1;fprime++) {
               for (k=1;k<=K;k++) {
                 add_constraint_eq25(i,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
                 add_constraint_eq25b(i,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		       }
		     }
		   }
	     }
	   }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=0;j<=tasks[i].nstages-1;j++) {
         for (iprime=1;iprime<=ntasks;iprime++) {
           for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
             for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
               for (fprime=0;fprime<=1;fprime++) {
                 for (k=1;k<=K;k++) {
                   add_constraint_eq26(i,j,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
                   add_constraint_eq26b(i,j,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		         }
		       }
		     }
		   }
	     }
	   }
     }
     for (i=1;i<=ntasks;i++) {
       for (j=0;j<=tasks[i].nstages-1;j++) {
         for (iprime=1;iprime<=ntasks;iprime++) {
           for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
             for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
               for (fprime=0;fprime<=1;fprime++) {
                 for (k=1;k<=K;k++) {
                   add_constraint_eq27(i,j,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
                   add_constraint_eq27b(i,j,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		         }
	  	       }
		     }
		   }
	     }
	   }
     }
     for (i=1;i<=ntasks;i++) {
       for (iprime=1;iprime<=ntasks;iprime++) {
         for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
           for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
             for (fprime=0;fprime<=1;fprime++) {
               for (k=1;k<=K;k++) {
                 add_constraint_eq28(i,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
                 add_constraint_eq28b(i,iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		       }
		     }
		   }
	     }
	   }
     }

     for (iprime=1;iprime<=ntasks;iprime++) {
       for (qprime=1;qprime<=(P/tasks[iprime].T);qprime++) {
         for (jprime=0;jprime<=tasks[iprime].nstages-1;jprime++) {
           for (fprime=0;fprime<=1;fprime++) {
             for (k=1;k<=K;k++) {
               add_constraint_eq29(iprime,qprime,jprime,fprime,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
		     }
		   }
	     }
	   }
     }
     for (k=1;k<=K;k++) {
       add_constraint_eq30(k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
     }
     for (i=1;i<=ntasks;i++) {
       for (k=1;k<=K;k++) {
         add_constraint_eq31(i,k);
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
	   }
     }
     add_constraint_eq32();
#if CALLGUROBITHROUGHAPI
		   error = GRBaddconstr( model, nelements_of_constr, ind, val, constraint_sense, constraint_rhs, NULL ); if (error) goto QUIT;
#else
		   myaddconstr( nelements_of_constr, ind, val, constraint_sense, constraint_rhs );
#endif                    
#if CALLGUROBITHROUGHAPI
   error = GRBupdatemodel( model);
   if (error) goto QUIT;

   error = GRBwrite( model, mipfnlp);
   if (error) goto QUIT;

   error = GRBupdatemodel( model);
   if (error) goto QUIT;
   error = GRBoptimize(model);
   if (error) goto QUIT;
   error = GRBupdatemodel( model);
   if (error) goto QUIT;
   error = GRBgetintattr( model, GRB_INT_ATTR_STATUS, &optimstatus);
   if (error) goto QUIT;
   error = GRBgetdblattr( model, GRB_DBL_ATTR_OBJVAL, &objval);
   if (error) goto QUIT;
   error = GRBgetdblattrarray( model, GRB_DBL_ATTR_X, 0, nelements_of_obj, sol);
   if (error) goto QUIT;
   localcounter = 0;
   while ((optimstatus!=GRB_OPTIMAL) && (localcounter<3)) {
     error = GRBupdatemodel( model);
     if (error) goto QUIT;
     error = GRBoptimize(model);
     if (error) goto QUIT;
     error = GRBupdatemodel( model);
     if (error) goto QUIT;
     error = GRBgetintattr( model, GRB_INT_ATTR_STATUS, &optimstatus);
     if (error) goto QUIT;
     error = GRBgetdblattr( model, GRB_DBL_ATTR_OBJVAL, &objval);
     if (error) goto QUIT;
     error = GRBgetdblattrarray( model, GRB_DBL_ATTR_X, 0, nelements_of_obj, sol);
     if (error) goto QUIT;
     localcounter = localcounter + 1;
   }

   if (optimstatus == GRB_OPTIMAL) {
	   *feas = 1;
	   *value = objval;
	   GRBwrite( model, mipfnsol );
	   GRBwrite( model, "temp.sol" );
           remove( outputfilename );    
           writetomemorymappingfile( outputfilename );
   } else {
     ;
   }
   QUIT:
   if (error) {
     printf("ERROR: %s\n", GRBgeterrormsg(env) );
	 // exit(1);
   }
   GRBfreemodel( model);
   GRBfreeenv( env);
#else
   write_the_end_of_lp_file( gurobithroughcommandlinelpfile);
   fclose( gurobithroughcommandlinelpfile);

   gurobithroughcommandlinepyfile  = fopen( gurobithroughcommandlinepyfilename,  "w");
   fprintf( gurobithroughcommandlinepyfile, "from gurobipy import *\n");
   fprintf( gurobithroughcommandlinepyfile, "m = read('%s')\n", gurobithroughcommandlinelpfilename);
   fprintf( gurobithroughcommandlinepyfile, "m.setParam('MIPFOCUS',%d)\n", myGRB_INT_PAR_MIPFOCUS );
   fprintf( gurobithroughcommandlinepyfile, "m.setParam('AGGREGATE',%d)\n", myGRB_INT_PAR_AGGREGATE );
   fprintf( gurobithroughcommandlinepyfile, "m.setParam('FEASIBILITYTOL',%25.15lf)\n", myGRB_DBL_PAR_FEASIBILITYTOL );
   fprintf( gurobithroughcommandlinepyfile, "m.setParam('INTFEASTOL',%25.15lf)\n", myGRB_DBL_PAR_INTFEASTOL  );
   fprintf( gurobithroughcommandlinepyfile, "m.setParam('MARKOWITZTOL',%25.15lf)\n", myGRB_DBL_PAR_MARKOWITZTOL  );
   fprintf( gurobithroughcommandlinepyfile, "m.setParam('QUAD',%d)\n", myGRB_INT_PAR_QUAD );
   fprintf( gurobithroughcommandlinepyfile, "m.setParam('NUMERICFOCUS',%d)\n", myGRB_INT_PAR_NUMERICFOCUS );
   fprintf( gurobithroughcommandlinepyfile, "m.setParam('HEURISTICS',%25.15lf)\n", myGRB_DBL_PAR_HEURISTICS );
   fprintf( gurobithroughcommandlinepyfile, "m.setParam('FEASRELAXBIGM',%25.15lf)\n", myGRB_DBL_PAR_FEASRELAXBIGM );
   fprintf( gurobithroughcommandlinepyfile, "m.update()\n");
   fprintf( gurobithroughcommandlinepyfile, "m.optimize()\n");
   fprintf( gurobithroughcommandlinepyfile, "m.update()\n");
   fprintf( gurobithroughcommandlinepyfile, "m.write('%s')\n", mipfnsol);
   fprintf( gurobithroughcommandlinepyfile, "exit()\n");
   fclose( gurobithroughcommandlinepyfile);
   create_Gurobi_command_line_for_executing_script();
   my_sleep(1);
   system(commandstringwithscript);
   my_sleep(1);
   if (fileexistsandisnotempty(mipfnsol)) {
     remove( outputfilename );    
     writetomemorymappingfile( outputfilename );
     *feas = 1;
   } else {
     *feas = 0;
   }
#endif
   freethememory();
   free_variables_needed_for_interacting_with_Gurobi();
}

int perform_schedulability_analysis()
{
  int var_feas; double var_value;
  perform_schedulability_analysis_internal( &var_feas, &var_value);
  return var_feas;
}

// The code below presents functions that perform schedulability analysis without considering memory contention
// derived parameters
// We do not use it now but we may use it in the future


#define MAXNTASKS 1000

// double schedulability_analysis_without_considering_memory_contention_C[MAXNTASKS+1];
// double schedulability_analysis_without_considering_memory_contention_eta[MAXNTASKS+1];
// double schedulability_analysis_without_considering_memory_contention_delta[MAXNTASKS+1];
// double schedulability_analysis_without_considering_memory_contention_u[MAXNTASKS+1];
double* schedulability_analysis_without_considering_memory_contention_C;
double* schedulability_analysis_without_considering_memory_contention_eta;
double* schedulability_analysis_without_considering_memory_contention_delta;
double* schedulability_analysis_without_considering_memory_contention_u;
double schedulability_analysis_without_considering_memory_contention_deltamax;
double schedulability_analysis_without_considering_memory_contention_U;

void schedulability_analysis_without_considering_memory_contention_do_memory_allocation()
{
  schedulability_analysis_without_considering_memory_contention_C = (double*) malloc( (MAXNTASKS+1)*sizeof(double) );
  if (schedulability_analysis_without_considering_memory_contention_C==NULL) { printf("Error in schedulability_analysis_without_considering_memory_contention_do_memory_allocation\n"); }

  schedulability_analysis_without_considering_memory_contention_eta = (double*) malloc( (MAXNTASKS+1)*sizeof(double) );
  if (schedulability_analysis_without_considering_memory_contention_eta==NULL) { printf("Error in schedulability_analysis_without_considering_memory_contention_do_memory_allocation\n"); }

  schedulability_analysis_without_considering_memory_contention_delta = (double*) malloc( (MAXNTASKS+1)*sizeof(double) );
  if (schedulability_analysis_without_considering_memory_contention_delta==NULL) { printf("Error in schedulability_analysis_without_considering_memory_contention_do_memory_allocation\n"); }

  schedulability_analysis_without_considering_memory_contention_u = (double*) malloc( (MAXNTASKS+1)*sizeof(double) );
  if (schedulability_analysis_without_considering_memory_contention_u==NULL) { printf("Error in schedulability_analysis_without_considering_memory_contention_do_memory_allocation\n"); }
}

void schedulability_analysis_without_considering_memory_contention_do_freeing_up_memory()
{
  free( schedulability_analysis_without_considering_memory_contention_C);
  free( schedulability_analysis_without_considering_memory_contention_eta);
  free( schedulability_analysis_without_considering_memory_contention_delta);
  free( schedulability_analysis_without_considering_memory_contention_u);
}

void schedulability_analysis_without_considering_memory_contention_compute_Cs()
{
  int i; int j;
  double temp;
  for (i=1;i<=ntasks;i++) {
    temp = 0;
    for (j=1;j<=tasks[i].nstages;j++) {
      temp = temp + (tasks[i].nsegments_of_stage[j]) * (tasks[i].exec_of_stage[j]);
	}
    schedulability_analysis_without_considering_memory_contention_C[i] = temp;
  }
}

void schedulability_analysis_without_considering_memory_contention_compute_etas()
{
  int i; int j;
  double temp;
  for (i=1;i<=ntasks;i++) {
    temp = 0;
    for (j=1;j<=tasks[i].nstages;j++) {
      temp = temp + tasks[i].exec_of_stage[j];
	}
    schedulability_analysis_without_considering_memory_contention_eta[i] = temp;
  }
}

void schedulability_analysis_without_considering_memory_contention_compute_deltas()
{
  int i;
  for (i=1;i<=ntasks;i++) {
    schedulability_analysis_without_considering_memory_contention_delta[i] =
      schedulability_analysis_without_considering_memory_contention_eta[i]/mindouble2(tasks[i].D,tasks[i].T);
  }
}

void schedulability_analysis_without_considering_memory_contention_compute_us()
{
  int i;
  for (i=1;i<=ntasks;i++) {
    schedulability_analysis_without_considering_memory_contention_u[i] = (schedulability_analysis_without_considering_memory_contention_C[i])/(tasks[i].T);
  }
}

void schedulability_analysis_without_considering_memory_contention_compute_deltamax()
{
  int i;
  schedulability_analysis_without_considering_memory_contention_deltamax = 0;
  for (i=1;i<=ntasks;i++) {
    schedulability_analysis_without_considering_memory_contention_deltamax = 
		maxdouble2( schedulability_analysis_without_considering_memory_contention_deltamax, schedulability_analysis_without_considering_memory_contention_delta[i] );
  }
}

void schedulability_analysis_without_considering_memory_contention_compute_U()
{
  int i;
  schedulability_analysis_without_considering_memory_contention_U = 0;
  for (i=1;i<=ntasks;i++) {
    schedulability_analysis_without_considering_memory_contention_U =
		schedulability_analysis_without_considering_memory_contention_U + schedulability_analysis_without_considering_memory_contention_u[i];
  }
}

void schedulability_analysis_without_considering_memory_contention_compute_derived_parameters()
{
  schedulability_analysis_without_considering_memory_contention_compute_Cs();
  schedulability_analysis_without_considering_memory_contention_compute_etas();
  schedulability_analysis_without_considering_memory_contention_compute_deltas();    // etas must be computed first
  schedulability_analysis_without_considering_memory_contention_compute_us();        // Cs must be computed first
  schedulability_analysis_without_considering_memory_contention_compute_deltamax();  // deltas must be computed first
  schedulability_analysis_without_considering_memory_contention_compute_U();         // us must be computed first
}

double schedulability_analysis_without_considering_memory_contention_getmaxttotest(double sigma)
{
  int i;
  double sumC;
  double denom;
  sumC = 0;
  for (i=1;i<=ntasks;i++) {
	  sumC = sumC + schedulability_analysis_without_considering_memory_contention_C[i];
  }
  denom = (nprocessors*s-(nprocessors-1)*(sigma/s)*s-schedulability_analysis_without_considering_memory_contention_U);
  return sumC/denom;
}
double schedulability_analysis_without_considering_memory_contention_sumCfirststages(int i,int j)
{
	int k;
	double sumC;
    sumC = 0;
	for (k=1;k<=j;k++) {
	  sumC = sumC + tasks[i].exec_of_stage[k];
	}
	return sumC;
}

void schedulability_analysis_without_considering_memory_contention_getnextt( double sigma, double t, double* pnextt, int* pvalidnextt)
{
  double maxttotest;
  int i; int j;
  int jobindex;
  int maxjobindex;
  double value_of_t;
  *pvalidnextt = 0;
  maxttotest = schedulability_analysis_without_considering_memory_contention_getmaxttotest( sigma);
  maxttotest = mindouble2( P, maxttotest);
  for (i=1;i<=ntasks;i++) {
    maxjobindex = ceil(maxttotest/(tasks[i].T))+1;
    for (jobindex=1;jobindex<=maxjobindex;jobindex++) {
      for (j=0;j<=tasks[i].nstages;j++) {
         value_of_t = (jobindex-1)*((tasks[i].T))+(tasks[i].D)-schedulability_analysis_without_considering_memory_contention_sumCfirststages(i,j)/sigma;
		 if ((t<value_of_t) && (value_of_t<=maxttotest)) {
			 if ((*pvalidnextt) == 0) {
               *pvalidnextt = 1;
			   *pnextt = value_of_t;
			 } else {
				 if (value_of_t<(*pnextt)) {
			       *pnextt = value_of_t;
				 }
			 }
		 }
	  }
	}
  }
}

int schedulability_analysis_without_considering_memory_contention_int_floor( int n1, int n2)
{
  return n1/n2;
}

int schedulability_analysis_without_considering_memory_contention_int_ceil( int n1, int n2)
{
  if (n1%n2==0)
    return n1/n2;
  else
    return n1/n2+1;
}

double schedulability_analysis_without_considering_memory_contention_WJS( int i, double t, int j, double locals)
{
	double ret;

	double busyspan;
	double span;
	int lastseg;
    busyspan = (tasks[i].exec_of_stage[j]/locals)*
		       schedulability_analysis_without_considering_memory_contention_int_floor(tasks[i].nsegments_of_stage[j],nprocessors);
	    span = (tasks[i].exec_of_stage[j]/locals)*
		       schedulability_analysis_without_considering_memory_contention_int_ceil(tasks[i].nsegments_of_stage[j],nprocessors);
	if ((0<=t) && (t<busyspan)) {
      ret = t*nprocessors*locals;
	} else {
   	  if ((busyspan<=t) && (t<span)) {
          lastseg = tasks[i].nsegments_of_stage[j] - 
			        schedulability_analysis_without_considering_memory_contention_int_floor( tasks[i].nsegments_of_stage[j],nprocessors ) * nprocessors;
		  ret = busyspan*nprocessors*locals + (t-busyspan)*lastseg*locals;
	  } else {
		ret = (tasks[i].exec_of_stage[j])*(tasks[i].nsegments_of_stage[j]) +
	      schedulability_analysis_without_considering_memory_contention_WJS( i, t-span, j+1, locals);
	  }
	}
	return ret;
}

double schedulability_analysis_without_considering_memory_contention_WJ( int i, double t, double locals)
{
	double ret;
	if (t<0) {
		ret = 0;
	}
	if ((0<=t) && (t<schedulability_analysis_without_considering_memory_contention_eta[i]/locals)) {
		ret = schedulability_analysis_without_considering_memory_contention_WJS( i, t, 1, locals);
	}
	if (schedulability_analysis_without_considering_memory_contention_eta[i]/locals<=t) {
		ret =  schedulability_analysis_without_considering_memory_contention_C[i];
	}
	return ret;
    printf("We have an error in WJ. This should not happen.\n");
	exit(-1);
}

double schedulability_analysis_without_considering_memory_contention_nhcWJS( int i, double t, int j, double locals)
{
	double busyspan;
	double span;
    busyspan = (tasks[i].exec_of_stage[j]/locals)*
		       schedulability_analysis_without_considering_memory_contention_int_floor(tasks[i].nsegments_of_stage[j],nprocessors);
        span = (tasks[i].exec_of_stage[j]/locals)*
		       schedulability_analysis_without_considering_memory_contention_int_ceil(tasks[i].nsegments_of_stage[j],nprocessors);

	if ((0<=t) && (t<busyspan)) {
      return busyspan;
	} else {
   	  if ((busyspan<=t) && (t<span)) {
        return span;
	  } else {
		return span + schedulability_analysis_without_considering_memory_contention_WJS( i, t-span, j+1, locals);
	  }
	}
}

double schedulability_analysis_without_considering_memory_contention_nhcWJ( int i, double t, double locals)
{
	if (t<0) {
		return 0;
	}
	if ((0<=t) && (t<schedulability_analysis_without_considering_memory_contention_eta[i]/locals)) {
		return schedulability_analysis_without_considering_memory_contention_nhcWJS( i, t, 1, locals);
	}
	if (schedulability_analysis_without_considering_memory_contention_eta[i]/locals<=t) {
		return tasks[i].T;
	}
    printf("We have an error in nhcWJ. This should not happen.\n");
	exit(-1);
}

int schedulability_analysis_without_considering_memory_contention_changesetisnonempty(double sigma, double t)
{
  int thereisanelement;
  int i;
  double r;
  thereisanelement = 0;
  for (i=1;i<=ntasks;i++) {
      r = t-floor( t/tasks[i].T)*(tasks[i].T);
	  if ((0<r) && (r<tasks[i].D)) {
        thereisanelement = 1;
	  }
  }
  return thereisanelement;
}

double schedulability_analysis_without_considering_memory_contention_computesigmafornewstage(double sigma, double t)
{
  int an_element_so_far;
  double min_so_far;
  int i;
  double r;
  double temp2;
  an_element_so_far = 0;
  for (i=1;i<=ntasks;i++) {
      r = t-floor( t/(tasks[i].T))*(tasks[i].T);
	  if ((0<r) && (r<(tasks[i].D))) {
		  temp2 = (schedulability_analysis_without_considering_memory_contention_nhcWJ(i,((tasks[i].D)-r)*sigma,1))/((tasks[i].D)-r); 
		  if (an_element_so_far==0) {
            min_so_far = temp2;
		  } else {
			  if (temp2<min_so_far) {
                min_so_far = temp2;
			  }
		  }
	  }
  }
  return min_so_far;
}

double schedulability_analysis_without_considering_memory_contention_ffdbf( int i, double t, double v, double locals)
{
  int q; double r;
  q = floor( t/(tasks[i].T));
  r = t-floor( t/(tasks[i].T))*(tasks[i].T);
  return q*schedulability_analysis_without_considering_memory_contention_C[i]+
	  schedulability_analysis_without_considering_memory_contention_C[i]-schedulability_analysis_without_considering_memory_contention_WJ( i, ((tasks[i].D)-r)*v, locals);
}

double schedulability_analysis_without_considering_memory_contention_compute_lhs( double sigma, double t)
{
  int i;
  double sum;
  sum = 0.0;
  for (i=1;i<=ntasks;i++) {
    sum = sum + schedulability_analysis_without_considering_memory_contention_ffdbf( i, t, sigma/s, s);
  }
  return sum;
}

double schedulability_analysis_without_considering_memory_contention_compute_rhs( double sigma, double t)
{
  return (nprocessors-(nprocessors-1)*(sigma/s))*t*s;
}

int schedulability_analysis_without_considering_memory_contention_evaluate_Eq_14( double sigma, double t)
{
  double lhs;
  double rhs;
  lhs = schedulability_analysis_without_considering_memory_contention_compute_lhs( sigma, t);
  rhs = schedulability_analysis_without_considering_memory_contention_compute_rhs( sigma, t);
  return lhs<=rhs;
}

double schedulability_analysis_without_considering_memory_contention_evalf( double sigma, double t)
{
  double lhs;
  double rhs;
  lhs = schedulability_analysis_without_considering_memory_contention_compute_lhs( sigma, t);
  rhs = schedulability_analysis_without_considering_memory_contention_compute_rhs( sigma, t);
  return lhs - rhs;
}

void schedulability_analysis_without_considering_memory_contention_getnextsigma( double sigma, double t, double* pnextsigma, int* pvalidnextsigma)
{
  double sigmacur;
  int foundsigmasought;
  double sigmafornewstage;
  double nextsigma;

  sigmacur = sigma;
  foundsigmasought = 0;

  while ((schedulability_analysis_without_considering_memory_contention_changesetisnonempty(sigmacur, t)==1) && (foundsigmasought==0)) {
    sigmafornewstage = schedulability_analysis_without_considering_memory_contention_computesigmafornewstage(sigmacur,t);
	if (schedulability_analysis_without_considering_memory_contention_evalf(sigmafornewstage,t)==0) {
      nextsigma = sigmafornewstage;
      foundsigmasought = 1;
	} else {
	  if (schedulability_analysis_without_considering_memory_contention_evalf(sigmafornewstage,t)>0) {
        sigmacur = sigmafornewstage;
	  } else {
        nextsigma = sigmacur + (schedulability_analysis_without_considering_memory_contention_evalf(sigmacur,t)/(schedulability_analysis_without_considering_memory_contention_evalf(sigmacur,t)-schedulability_analysis_without_considering_memory_contention_evalf(sigmafornewstage,t))) * (sigmafornewstage-sigmacur);
        foundsigmasought = 1;
	  }
	}
  }
  if (foundsigmasought==1) {
    *pnextsigma = sigmacur;
	*pvalidnextsigma = 1;
  } else {
	*pvalidnextsigma = 0;
  }
}

int schedulability_analysis_without_considering_memory_contention_perform_schedulability_analysis()
{
	double sigma;
	double t;
	int foundwitness;
	int validsigma;
	double nextt;
	int validnextt;
	double nextsigma;
	int eval;
	int validnextsigma;
	schedulability_analysis_without_considering_memory_contention_compute_derived_parameters();

	sigma = schedulability_analysis_without_considering_memory_contention_deltamax;
	t = 0.0;
	foundwitness = 0;
	validsigma =
		(sigma/s<=(nprocessors*s-schedulability_analysis_without_considering_memory_contention_U)/((nprocessors-1)*s));
	while ((foundwitness==0) && (validsigma==1)) {
      schedulability_analysis_without_considering_memory_contention_getnextt( sigma, t, &nextt, &validnextt);      
	  eval = 1;
	  while ((validnextt==1) && (eval==1)) {
        t = nextt;
		eval = schedulability_analysis_without_considering_memory_contention_evaluate_Eq_14( sigma, t);
        schedulability_analysis_without_considering_memory_contention_getnextt( sigma, t, &nextt, &validnextt);
	  }
	  if (eval==1) {
		  foundwitness = 1;
	  } else {
		schedulability_analysis_without_considering_memory_contention_getnextsigma( sigma, t, &nextsigma, &validnextsigma);
		if ( (validnextsigma==1) && (nextsigma/s<=(nprocessors*s-schedulability_analysis_without_considering_memory_contention_U)/((nprocessors-1)*s)) ) {
			sigma = nextsigma;
			validsigma = 1;
		} else {
			validsigma = 0;
		}
	  }
	}
	if (foundwitness==1) {
		printf("Schedulable. Witness: %lf\n", sigma);
	} else {
		printf("Unschedulable\n");
	}
	return foundwitness;
}

void schedulability_analysis_without_considering_memory_contention_getnextt2( double t, double* pnextt, int* pvalidnextt)
{
  double maxttotest;
  int i; int j;
  int jobindex;
  int maxjobindex;
  double value_of_t;
  *pvalidnextt = 0;
  maxttotest = schedulability_analysis_without_considering_memory_contention_getmaxttotest( 0.0);
  maxttotest = mindouble2( P, maxttotest);
  for (i=1;i<=ntasks;i++) {
    maxjobindex = ceil(maxttotest/(tasks[i].T))+1;
    for (jobindex=1;jobindex<=maxjobindex;jobindex++) {
      for (j=0;j<=tasks[i].nstages;j++) {
         value_of_t = (jobindex-1)*(tasks[i].T)+(tasks[i].D)-schedulability_analysis_without_considering_memory_contention_sumCfirststages(i,j);
		 if ((t<value_of_t) && (value_of_t<=maxttotest)) {
			 if ((*pvalidnextt) == 0) {
               *pvalidnextt = 1;
			   *pnextt = value_of_t;
			 } else {
				 if (value_of_t<(*pnextt)) {
			       *pnextt = value_of_t;
				 }
			 }
		 }
	  }
	}
  }
}

int schedulability_analysis_without_considering_memory_contention_evaluate_this_point( double t)
{
  double lhs;
  double rhs;
  lhs = schedulability_analysis_without_considering_memory_contention_compute_lhs( s, t);
  rhs = schedulability_analysis_without_considering_memory_contention_compute_rhs( 0, t);
  return lhs<=rhs;
}

int schedulability_analysis_without_considering_memory_contention_check_that_that_taskset_is_not_infeasible()
{
	double sigma;
	double t;
	int foundwitness;
	int validsigma;
	double nextt;
	int validnextt;
	double nextsigma;
	int eval;
	int validnextsigma;
        schedulability_analysis_without_considering_memory_contention_do_memory_allocation();
	schedulability_analysis_without_considering_memory_contention_compute_derived_parameters();

	if (schedulability_analysis_without_considering_memory_contention_U>nprocessors*s) {
	  return 0;
    }

	t = 0.0;
      schedulability_analysis_without_considering_memory_contention_getnextt2( t, &nextt, &validnextt);      
	  eval = 1;
	  while ((validnextt==1) && (eval==1)) {
        t = nextt;
		eval = schedulability_analysis_without_considering_memory_contention_evaluate_this_point( t);
        schedulability_analysis_without_considering_memory_contention_getnextt2( t, &nextt, &validnextt);
	  }
	  if (eval==1) {
		  foundwitness = 1;
	  } else {
		  foundwitness = 0;
	  }
        schedulability_analysis_without_considering_memory_contention_do_freeing_up_memory();
	if (foundwitness==1) {
		printf("Schedulable.\n");
	} else {
		printf("Unschedulable\n");
	}
	return foundwitness;
}

void generate_figure_5_in_paper()
{
  setsystem1( 4, 0.040, 1.0);
  compute_derived_parameters();  
  printsystem();
}

#if COMPILEMSVS || COMPILEWIN32
  unsigned long long diff_us_timeval(struct timeval *x, struct timeval *y)
 {
  unsigned long long amillion = 1000000;
  unsigned long long u = ((x->tv_sec * amillion) + x->tv_usec);
  unsigned long long v = ((y->tv_sec * amillion) + y->tv_usec);
  return u-v;
}
double diff_s_timeval(struct timeval *x, struct timeval *y){
  unsigned long long amillion = 1000000;
  unsigned long long t;
  unsigned long long tsec;
  unsigned long long tusec;
  double t_as_double_secondpart;
  double t_as_double_usecondpart;
  double t_as_double;

  t = diff_us_timeval( x, y);
  tsec = t / amillion;
  tusec =  t % amillion; 
  t_as_double_secondpart = tsec;
  t_as_double_usecondpart = tusec;
  t_as_double_usecondpart = t_as_double_usecondpart / amillion;
  t_as_double = t_as_double_secondpart + t_as_double_usecondpart; 
  return t_as_double;
}
#else
  unsigned long long diff_ns_timespec(struct timespec *x, struct timespec *y)
 {
  unsigned long long abillion = 1000000000;
  unsigned long long u = ((x->tv_sec * abillion) + x->tv_nsec);
  unsigned long long v = ((y->tv_sec * abillion) + y->tv_nsec);
  return u-v;
}
double diff_s_timespec (struct timespec *x, struct timespec *y){
  unsigned long long abillion = 1000000000;
  unsigned long long t;
  unsigned long long tsec;
  unsigned long long tnsec;
  double t_as_double_secondpart;
  double t_as_double_usecondpart;
  double t_as_double;

  t = diff_ns_timespec( x, y);
  tsec = t / abillion;
  tnsec =  t % abillion; 
  t_as_double_secondpart = tsec;
  t_as_double_usecondpart = tnsec;
  t_as_double_usecondpart = t_as_double_usecondpart / abillion;
  t_as_double = t_as_double_secondpart + t_as_double_usecondpart; 
  return t_as_double;
}
#endif

#define CLOCK_REALTIME 0

#if COMPILEMSVS || COMPILEWIN32

LARGE_INTEGER getFILETIMEoffset()
{
    SYSTEMTIME s;
    FILETIME f;
    LARGE_INTEGER t;

    s.wYear = 1970;
    s.wMonth = 1;
    s.wDay = 1;
    s.wHour = 0;
    s.wMinute = 0;
    s.wSecond = 0;
    s.wMilliseconds = 0;
    SystemTimeToFileTime(&s, &f);
    t.QuadPart = f.dwHighDateTime;
    t.QuadPart <<= 32;
    t.QuadPart |= f.dwLowDateTime;
    return (t);
}
 
int my_clock_gettime(int X, struct timeval *tv)
{
    LARGE_INTEGER           t;
    FILETIME            f;
    double                  microseconds;
    static LARGE_INTEGER    offset;
    static double           frequencyToMicroseconds;
    static int              initialized = 0;
    static BOOL             usePerformanceCounter = 0;

    if (!initialized) {
        LARGE_INTEGER performanceFrequency;
        initialized = 1;
        usePerformanceCounter = QueryPerformanceFrequency(&performanceFrequency);
        if (usePerformanceCounter) {
            QueryPerformanceCounter(&offset);
            frequencyToMicroseconds = (double)performanceFrequency.QuadPart / 1000000.;
        } else {
            offset = getFILETIMEoffset();
            frequencyToMicroseconds = 10.;
        }
    }
    if (usePerformanceCounter) QueryPerformanceCounter(&t);
    else {
        GetSystemTimeAsFileTime(&f);
        t.QuadPart = f.dwHighDateTime;
        t.QuadPart <<= 32;
        t.QuadPart |= f.dwLowDateTime;
    }

    t.QuadPart -= offset.QuadPart;
    microseconds = (double)t.QuadPart / frequencyToMicroseconds;
    t.QuadPart = microseconds;
    tv->tv_sec = t.QuadPart / 1000000;
    tv->tv_usec = t.QuadPart % 1000000;
    return (0);
}
#endif

void fillsuccessstring(int thissuccess,char* thissuccessstring)
{
  if (thissuccess==0) {
    strcpy(thissuccessstring," no");
  } else {
    if (thissuccess==1) {
      strcpy(thissuccessstring,"yes");
    } else {
      printf("Error in fillsuccessstring\n"); exit(-1);
    }
  }
}

void print_table_txt_file_as_tex(int mselection, char* finfilename, char* foutfilename)
{
  char buf[2000];
  FILE* fin; FILE* fout;
  int thism; double thisC12; double thismult; double thistime; int thissuccess; char thissuccessstring[2000];
  fin = fopen( finfilename, "r"); fout = fopen( foutfilename, "w");
  fprintf(fout,"\\begin{table}[t!]\n");
  fprintf(fout,"\\begin{scriptsize}\n");
  fprintf(fout,"\\begin{tabular}{|r|r|r|r|} \\hline\n");
  fprintf(fout,"$C_{1,2}$  & mult                                    & Time            &                        \\\\                   \n"); 
  fprintf(fout,"(seconds)  & $\\mathrm{MA}_{i,j,p}$                   & (seconds)       & Schedulable            \\\\ \\hline \\hline   \n");

  while (fgets( buf, 2000, fin)!=NULL) {
    sscanf(buf,"%d %lf %lf %lf %d", &thism, &thisC12, &thismult, &thistime, &thissuccess);
    if (thism==mselection) {
      fillsuccessstring(thissuccess,thissuccessstring);
      fprintf(fout," %6.3lf    & %6.3lf                                  & %6.1lf          & %s \\\\ \n", thisC12, thismult, thistime, thissuccessstring);
    }
  }
  fprintf(fout,"\\hline\n");

  fprintf(fout,"\\end{tabular}\n");
  fprintf(fout,"\\end{scriptsize}\n");
  fprintf(fout,"\\caption{Results from evaluation ($m=%d$).}\n", mselection);
  fprintf(fout,"\\label{tab:results_from_evaluation_m%d}\n", mselection);
  fprintf(fout,"\\end{table}\n");
  fclose( fin); fclose( fout);
}

void print_table_II_as_tex()
{
  print_table_txt_file_as_tex(4,"table2_and_table3_data.txt","table2.tex");
}

void print_table_III_as_tex()
{
  print_table_txt_file_as_tex(8,"table2_and_table3_data.txt","table3.tex");
}

int number_of_elements_stored_here;
double elements_stores_here[10000];

void getthirdnumber(char* buf, double* pt3, int* pflag)
{
  char* p;
  char* p2;
  char* p3;
  *pflag = 0;
  p = strchr(buf,'&');
  if (p!=NULL) {
    p2 = strchr(p+1,'&');
    if (p2!=NULL) {
      p3 = strchr(p2+1,'&');
      if (p3!=NULL) {
        *p3 = 0;
        sscanf(p2+1,"%lf", pt3 );
        *pflag = 1;
      }
    }
  }   
}

void fillinalldatastoredhere(char* finfilename)
{
  char buf[2000];
  char* p;
  char* p2;
  char* p3;
  FILE* fin;
  double thistime;
  int flag;
  number_of_elements_stored_here = 0;
  fin = fopen( finfilename, "r");
  fgets( buf, 2000, fin);
  while (buf[0]=='\\') {
    fgets( buf, 2000, fin);
  }
  // we have already read first line in header
  fgets( buf, 2000, fin); // we read second line in header
  fgets( buf, 2000, fin); // we get real data
  getthirdnumber( buf, &thistime, &flag);
  elements_stores_here[number_of_elements_stored_here] = thistime; 
  number_of_elements_stored_here = number_of_elements_stored_here + 1;
  while ((fgets( buf, 2000, fin)!=NULL) && (flag)) { // we get real data
    getthirdnumber( buf, &thistime, &flag);
    elements_stores_here[number_of_elements_stored_here] = thistime; 
    number_of_elements_stored_here = number_of_elements_stored_here + 1;
  }
}

void sortdatastoredhere()
{
  int index1;
  int index2;
  double temp;
  for (index1=0;index1<number_of_elements_stored_here;index1++) {
    for (index2=index1+1;index2<number_of_elements_stored_here;index2++) {
      if (elements_stores_here[index2] < elements_stores_here[index1]) {
        temp = elements_stores_here[index2];
        elements_stores_here[index2] = elements_stores_here[index1];
        elements_stores_here[index1] = temp;
      } 
    }
  }
}

double getmin_for_statistics(char* finfilename)
{
  double element_to_return;
  int index1; int index2;
  fillinalldatastoredhere(finfilename);
  sortdatastoredhere();
  index1 = 0;
  element_to_return = elements_stores_here[index1];
  return element_to_return;
}
double getmax_for_statistics(char* finfilename)
{
  double element_to_return;
  int index1; int index2;
  fillinalldatastoredhere(finfilename);
  sortdatastoredhere();
  index1 = number_of_elements_stored_here-1;
  element_to_return = elements_stores_here[index1];
  return element_to_return;
}
double getmedian_for_statistics(char* finfilename)
{
  double element_to_return;
  int index1; int index2;
  fillinalldatastoredhere(finfilename);
  sortdatastoredhere();
  if (number_of_elements_stored_here%2==1) {
    index1 = (number_of_elements_stored_here-1)/2;
    element_to_return = elements_stores_here[index1];
  } else {
    index1 = (number_of_elements_stored_here-1)/2;
    index2 = (number_of_elements_stored_here+1)/2;
    element_to_return = (elements_stores_here[index1] + 
                         elements_stores_here[index2]) / 2.0;
  }
  return element_to_return;
}
double getq1_for_statistics(char* finfilename)
{
  double element_to_return;
  int index1; int index2;
  fillinalldatastoredhere(finfilename);
  sortdatastoredhere();
  index1 = (number_of_elements_stored_here-1)*1/4;
  element_to_return = elements_stores_here[index1];
  return element_to_return;
}
double getq3_for_statistics(char* finfilename)
{
  double element_to_return;
  int index1; int index2;
  fillinalldatastoredhere(finfilename);
  sortdatastoredhere();
  index1 = (number_of_elements_stored_here-1)*3/4;
  element_to_return = elements_stores_here[index1];
  return element_to_return;
}

void print_statistics(char* finfilenamem4, char* finfilenamem8, char* foutstatisticsfilename)
{
  FILE* fout;
  fout = fopen( foutstatisticsfilename, "w");
  fprintf(fout,"\\begin{table}[t!]\n");
  fprintf(fout,"\\centering\n");
  fprintf(fout,"\\begin{small}\n");
  fprintf(fout,"\\begin{tabular}{|l|r|r|} \\hline\n");
  fprintf(fout,"                                   & m=4    & m=8    \\\\  \\hline \\hline\n");
  fprintf(fout,"min                                & %7.0lf & %7.0lf \\\\ \n", getmin_for_statistics(finfilenamem4),    getmin_for_statistics(finfilenamem8)    );
  fprintf(fout,"q1                                 & %7.0lf & %7.0lf \\\\ \n", getq1_for_statistics(finfilenamem4),     getq1_for_statistics(finfilenamem8)     );
  fprintf(fout,"median                             & %7.0lf & %7.0lf \\\\ \n", getmedian_for_statistics(finfilenamem4), getmedian_for_statistics(finfilenamem8) );
  fprintf(fout,"q3                                 & %7.0lf & %7.0lf \\\\ \n", getq3_for_statistics(finfilenamem4),     getq3_for_statistics(finfilenamem8)     );
  fprintf(fout,"max                                & %7.0lf & %7.0lf \\\\ \n", getmax_for_statistics(finfilenamem4),    getmax_for_statistics(finfilenamem8)    );
  fprintf(fout,"\\hline \n");
  fprintf(fout,"\\end{tabular} \n");
  fprintf(fout,"\\end{small} \n");
  fprintf(fout,"\\caption{Five number summary of the time required, in our experiments, for performing schedulability analysis and configuring memory (in seconds).} \n");
  fprintf(fout,"\\label{tab:time_required_m4_m8} \n");
  fprintf(fout,"\\end{table} \n");
  fclose( fout);
}

/*
void print_statistics(char* finfilenamem4, char* finfilenamem8, char* foutstatisticsfilename)
{
  FILE* fout;
  fout = fopen( foutstatisticsfilename, "w");
  fprintf(fout,"Statistics m=4  m=8\n");
  fprintf(fout,"min        %8.2lf   %8.2lf\n", getmin_for_statistics(finfilenamem4),    getmin_for_statistics(finfilenamem8) );
  fprintf(fout,"q1         %8.2lf   %8.2lf\n", getq1_for_statistics(finfilenamem4),     getq1_for_statistics(finfilenamem8) );
  fprintf(fout,"median     %8.2lf   %8.2lf\n", getmedian_for_statistics(finfilenamem4), getmedian_for_statistics(finfilenamem8) );
  fprintf(fout,"q3         %8.2lf   %8.2lf\n", getq3_for_statistics(finfilenamem4),     getq3_for_statistics(finfilenamem8) );
  fprintf(fout,"max        %8.2lf   %8.2lf\n", getmax_for_statistics(finfilenamem4),    getmax_for_statistics(finfilenamem8) );
  fclose( fout);
}
*/

// void print_table_II_as_tex()
// {
//   print_statistics("table2.tex","table3.tex","statisticsfilename.txt");
// }

void generate_Table_II_and_Table_III_in_paper()
{
    int counter3;
    FILE* f;
	int targetnprocessors;
	double C12;
        double mult;
	#if COMPILEMSVS || COMPILEWIN32
	  struct timeval mybegin;
	  struct timeval myend;
    #else
	  struct timespec mybegin;
	  struct timespec myend;
    #endif
    
    double timerequiredforschedulabilityanalysis;  
	int success;

    f = fopen( "table2_and_table3_data.txt", "w");
    for (targetnprocessors=4;targetnprocessors<=8;targetnprocessors*=2) {
      for (C12=0.005;C12<=0.005*10;C12+=0.005) {
        for (counter3=0;counter3<=8;counter3+=1) {
          if (counter3==0) { mult =   0.00; }
          if (counter3==1) { mult =   0.01; }
          if (counter3==2) { mult =   0.10; }
          if (counter3==3) { mult =   0.25; }
          if (counter3==4) { mult =   0.50; }
          if (counter3==5) { mult =   1.00; }
          if (counter3==6) { mult =   2.00; }
          if (counter3==7) { mult =   4.00; }
          if (counter3==8) { mult =  10.00; }
          setsystem1( targetnprocessors, C12, mult);
          compute_derived_parameters();  
		  printsystem(); // this is for checking that everything is OK. We can delete this line if we want to

          #if COMPILEMSVS || COMPILEWIN32
	          my_clock_gettime(CLOCK_REALTIME, &mybegin);
          #else
	          clock_gettime(CLOCK_REALTIME, &mybegin);
          #endif

          success = perform_schedulability_analysis();

          #if COMPILEMSVS || COMPILEWIN32
	          my_clock_gettime(CLOCK_REALTIME, &myend);
          #else
	          clock_gettime(CLOCK_REALTIME, &myend);
          #endif

	  #if COMPILEMSVS || COMPILEWIN32
            timerequiredforschedulabilityanalysis =  diff_s_timeval(&myend, &mybegin);
          #else
            timerequiredforschedulabilityanalysis =  diff_s_timespec(&myend, &mybegin);
          #endif
          fprintf( f, "%d %lf %lf %lf %d\n", targetnprocessors, C12, mult, timerequiredforschedulabilityanalysis, success);  fflush( f);
          fclose( f); // we close and then open the file again in append mode. The reason for this is that guarantees that
                      // the file is written to disk and hence the most recent writes are visible to others.
                      // This is important on windows machines, where a fflush is not enough.
          f = fopen( "table2_and_table3_data.txt", "a");
          deallocatetheentiresystem();
        }
      }
    }
    fclose( f);
}

// this code does the same as the function above but instead of generating a system with setsystem1, it calls setsystem1_smaller
// Also, it only analyzes a system with 4 processors (that is, no analysis for system with 8 processors)
void generate_Table_II_and_Table_III_in_paper_smaller()
{
    int counter3;
    FILE* f;
	int targetnprocessors;
	double C12;
        double mult;
	#if COMPILEMSVS || COMPILEWIN32
	  struct timeval mybegin;
	  struct timeval myend;
    #else
	  struct timespec mybegin;
	  struct timespec myend;
    #endif
    
    double timerequiredforschedulabilityanalysis;  
	int success;

    f = fopen( "table2_and_table3_data.txt", "w");
    for (targetnprocessors=4;targetnprocessors<=4;targetnprocessors*=2) {
      for (C12=0.005;C12<=0.005*10;C12+=0.005) {
        for (counter3=0;counter3<=8;counter3+=1) {
          if (counter3==0) { mult =   0.00; }
          if (counter3==1) { mult =   0.01; }
          if (counter3==2) { mult =   0.10; }
          if (counter3==3) { mult =   0.25; }
          if (counter3==4) { mult =   0.50; }
          if (counter3==5) { mult =   1.00; }
          if (counter3==6) { mult =   2.00; }
          if (counter3==7) { mult =   4.00; }
          if (counter3==8) { mult =  10.00; }
          setsystem1_smaller( targetnprocessors, C12, mult);
          compute_derived_parameters();  
		  printsystem(); // this is for checking that everything is OK. We can delete this line if we want to

          #if COMPILEMSVS || COMPILEWIN32
	          my_clock_gettime(CLOCK_REALTIME, &mybegin);
          #else
	          clock_gettime(CLOCK_REALTIME, &mybegin);
          #endif

          success = perform_schedulability_analysis();

          #if COMPILEMSVS || COMPILEWIN32
	          my_clock_gettime(CLOCK_REALTIME, &myend);
          #else
	          clock_gettime(CLOCK_REALTIME, &myend);
          #endif

	  #if COMPILEMSVS || COMPILEWIN32
            timerequiredforschedulabilityanalysis =  diff_s_timeval(&myend, &mybegin);
          #else
            timerequiredforschedulabilityanalysis =  diff_s_timespec(&myend, &mybegin);
          #endif
          fprintf( f, "%d %lf %lf %lf %d\n", targetnprocessors, C12, mult, timerequiredforschedulabilityanalysis, success);  fflush( f);
          fclose( f); // we close and then open the file again in append mode. The reason for this is that guarantees that
                      // the file is written to disk and hence the most recent writes are visible to others.
                      // This is important on windows machines, where a fflush is not enough.
          f = fopen( "table2_and_table3_data.txt", "a");
          deallocatetheentiresystem();
        }
      }
    }
    fclose( f);
}

void do_meta_mode()
{
  generate_Table_II_and_Table_III_in_paper();
  print_table_II_as_tex();
  print_table_III_as_tex();
  print_statistics("table2.tex","table3.tex","statisticsfilename.txt");
}

void do_metatwo_mode()
{
  generate_Table_II_and_Table_III_in_paper_smaller();
  print_table_II_as_tex();
  // In metamodetwo, we only consider the case with four processors so there is no such thing as table_III
  // Also, we do not put together the 5-number statistics. Therefore, we comment out the two lines below.
  // print_table_III_as_tex();
  // print_statistics("table2.tex","table3.tex","statisticsfilename.txt");
}

void do_generate_system()
{
  setsystem1( 4, 0.030, 1.0);
  printsystemtofilewithname("generated_system.txt");
  deallocatetheentiresystem();
}

void printfilewithsuccessandmemorymapping(char* outputfilename, int success)
{
  FILE* f;
  f = fopen( outputfilename, "w");
  fprintf( f, "%d\n", success);

  fclose( f);
}

void do_single_run()
{
  int success;
  counterforILPsolver = 1;
  initializesystem();
  success = perform_schedulability_analysis();
  deallocatetheentiresystem();
}

void parsearguments( int argc, char *argv[], char *envp[])
{
	int i;
	i = 1;
	while (i<=argc-1) {
	  if (strcmp( argv[i], "-i")==0) {
            strcpy( inputfilename, argv[i+1] );
            i = i + 2;
	  } else {
	    if (strcmp( argv[i], "-o")==0) {
              strcpy( outputfilename, argv[i+1] );
              i = i + 2;
            } else {
	      if (strcmp( argv[i], "-m")==0) {
                meta_mode = 1;
                i = i + 1;
	      } else {
	        if (strcmp( argv[i], "-p")==0) {
                  gurobipathisset = 1;
                  strcpy( gurobipath, argv[i+1] );
                  i = i + 2;
	        } else {
	          if (strcmp( argv[i], "-g")==0) {
                    generate_one_system_mode = 1;
                    i = i + 1;
	          } else {
	            if (strcmp( argv[i], "-m2")==0) {
                      metatwo_mode = 1;
                      i = i + 1;
	            } else {
		      i++;
                    }
                  }
                }
              }
	    }
          }
	}
}

int inputfilenameexists()
{
  FILE* fin; int ret_val;
  fin = fopen( inputfilename, "r");
  if (fin!=NULL) {  
    fclose(fin);
    ret_val = 1;
  } else {
    ret_val = 0;
  }
  return ret_val;
}

int main( int argc, char *argv[], char *envp[])
{
  parsearguments(argc, argv, envp);
  if (meta_mode==1) {
    do_meta_mode();
  }
  if (metatwo_mode==1) {
    do_metatwo_mode();
  }
  if (generate_one_system_mode==1) {
    do_generate_system();
  }
  if (inputfilenameexists()) {
    counterforILPsolver = 1;
    do_single_run();
  }
  return 0;
}