#include <stdio.h>
#include <string.h>
#include <math.h>
#include <errno.h>
#include <stdlib.h>
#include <time.h>
#include <ctype.h>

typedef enum {
  FALSE, TRUE
}               boolean;

#define  G       20
#define  N       300

time_t          time(time_t *);
time_t          t0, t1, t2;

char            DateiAlt[15], Datei[15], Zeile[80];
FILE           *fid, *stream;
double          *scone, **sc,  **c;
int           **nof4, **fct, *graph, *x, *subs, *SumNof, **nof;
int             l[G], org[G], sl[G], cl[G], slone;
int             worklist, b, B, Bmax, Bsave, Cmax, Gmax, Test = 21;
//Test = 7589;
//Test = 2407;
//Test = 997;
//Test = 5737;
//Test = 13483;
//Test = 3311;

char            T[N][10], letter, letter3, letter2;
double          w[N], p[N];
int             wl[N][10];
int             M, Nr;
double          A, Ai;
boolean         Treffer;


void
fatal(char *msg)
{
  fprintf(stderr, "Not enough memory for array %s  available !!\n", msg);
  exit(1);
}

int
loadWorklist(int M)
{
  int             i, j, k;

  sprintf(DateiAlt, "wl%02db%02d.dat", b, M);
  printf("  Loading: %s\n", DateiAlt);
  stream = fopen(DateiAlt, "r");
  if (stream == NULL) {
    printf("File %s does not exist !!!\n", DateiAlt);
    exit(1);
  }
  /******* Datei lesen und anzeigen  *************/
  for (k = 0; k < N; k++)
    for (i = 0; i < 10; i++)
      wl[k][i] = 0;

  i = 0;
  while (!feof(stream)) {
    fscanf(stream, "%s", Zeile);
    printf("%d) ", i);
    letter = Zeile[0];
    letter3 = Zeile[2];
    letter2 = Zeile[1];
    for (j = 0; j <= 2; j++) {
      T[i][j] = tolower(Zeile[j]);
      if (letter != '*')
	printf("%c", T[i][j]);
    }
    switch (letter) {
    case '*':
      printf("%s\n", Zeile);
      break;
   case 'c':
        if (letter2 == '1') {
          for (k = 1; k <= 2; k++) {
            fscanf(stream, "%s", Zeile);
            wl[i][k] = atoi(Zeile);
          }
          printf("   cost 1: (%d,%d)", wl[i][1], wl[i][2]);
        }

        if (letter2 == '2') {
          for (k = 1; k <= 4; k++) {
            fscanf(stream, "%s", Zeile);
            wl[i][k] = atoi(Zeile);
          }
          printf("   cost 2: (%d,%d,%d,%d)", wl[i][1], wl[i][2], wl[i][3], wl[i][4]);
        }
     if (letter2 == '3') {
       for (k = 1; k <= 6; k++) {
         fscanf(stream, "%s", Zeile);
         wl[i][k] = atoi(Zeile);
       }
       printf("   cost 3: (%d,%d,%d,%d,%d,%d)", wl[i][1], wl[i][2], wl[i][3], wl[i][4], wl[i][5], wl[i][6]);
     }
     if (letter2 == '4') {
       for (k = 1; k <= 8; k++) {
         fscanf(stream, "%s", Zeile);
         wl[i][k] = atoi(Zeile);
       }
       printf("   cost 4: (%d,%d,%d,%d,%d,%d,%d,%d)", wl[i][1], wl[i][2], wl[i][3], wl[i][4], wl[i][5], wl[i][6], wl[i][7], wl[i][8]);
     }
     if (letter2 == '5') {
       for (k = 1; k <= 10; k++) {
         fscanf(stream, "%s", Zeile);
         wl[i][k] = atoi(Zeile);
       }
       printf("   cost 5: (%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)", wl[i][1], wl[i][2], wl[i][3], wl[i][4], wl[i][5], wl[i][6], wl[i][7], wl[i][8], wl[i][9], wl[i][10]);
     }
       printf("\n");
      break;
    case 'a':
      //for mul and add
	  fscanf(stream, "%s", Zeile);
      wl[i][1] = atoi(Zeile);
      fscanf(stream, "%s", Zeile);
      wl[i][2] = atoi(Zeile);
      printf("  (%d,%d) \n", wl[i][1], wl[i][2]);
      break;
    case 'f':
      //for mul and add
	  fscanf(stream, "%s", Zeile);
      wl[i][1] = atoi(Zeile);
      printf("  (%d) \n", wl[i][1]);
      break;
    case 'm':
      //for mul and add
	  fscanf(stream, "%s", Zeile);
      wl[i][1] = atoi(Zeile);
      fscanf(stream, "%s", Zeile);
      wl[i][2] = atoi(Zeile);
      printf("  (%d,%d) \n", wl[i][1], wl[i][2]);
      break;
    default:
      printf("\n");
      break;
    }
    i++;
  };
  while ((T[i][0] <= 'a') || (T[i][0] >= 'z')) {
    i--;
  }
  fclose(stream);
  printf("\n End of LOAD design ! i=%d \n", i);
  return i;
}


int
getarrays()
{
  int             j;

  /***** define the structure to compute coefficient, i.e. C_k*C_l, C_k+C_l **/
  if ((graph = (int *) calloc(Bmax, sizeof(int))) == NULL) {
    printf("Not enough memory for array %s available\n", "graph");
    exit(1);
  }
  fct = (int **) calloc(4, sizeof(int));
  for (j = 0; j < 4; j++) {
    fct[j] = (int *) calloc(Bmax, sizeof(int));
    if (fct == NULL)
      fatal("fct");
  }
  /** none output fundamentals or factor in mag coding ***/
  nof4 = (int **) calloc(4, sizeof(int));
  for (j = 0; j < 4; j++) {
    nof4[j] = (int *) calloc(Bmax, sizeof(int));
    if (nof4 == NULL)
      fatal("nof4");
  }
  /** cost arrays store all double of cost c ***/
  c = (double **) calloc(Gmax + 1, sizeof(double));
  for (j = 0; j <= Gmax; j++) {
    c[j] = (double *) calloc(Cmax, sizeof(double));
    if (c == NULL)
      fatal("c");
  }
  /** signed cost arrays store all positive first than negative ***/
  sc = (double **) calloc(Gmax + 1, sizeof(double));
  for (j = 0; j <= Gmax; j++) {
    sc[j] = (double *) calloc(2 * Cmax, sizeof(double));
    if (sc == NULL)
      fatal("sc");
  }
  /** signed odd only cost one arrays  ***/
    scone = (double *) calloc(Cmax, sizeof(double));
    if (scone == NULL)
      fatal("scone");
  return (0);
}
/********** sort array ********/
void
sort(int *x, int l1)
{
  int             k, j, t;

  for (k = 1; k < l1; k++) {
    t = x[j = k + 1];
    while (j != 1 && x[j - 1] > t) {
      x[j] = x[j - 1];
      j--;
    }
    x[j] = t;
  }
}
/********** ADSIP.M ********/
void
adisp(char *str, int *x, int l1)
{
  int             k;
  printf("%s = ", str);
  for (k = 1; k <= l1; k++) {
    printf(" %d", x[k]);
    if ((k % 15) == 0)
      printf("\n");
  }
  printf("\n");
}

/***** Compute odd fundamental *************/
int
oddfund(int coeff)
{
  int             x;
  x = abs(coeff);
  if (x == 0)
    return (x);
  while ((x % 2) == 0) {
    x = x / 2;
  }
  return (x);
}

void
find(int g)
{
  int             k = 0;
  printf("*** Find factor with costs %d\n", g);
  fprintf(fid, "*** Find factor with costs %d\n", g);
  /*
   * printf("*** First 5 costs factors\n"); for (k=1;k<6;k++) printf("C(0)=%d
   * C(1)=%d C(2)=%d C(3)=%d
   * C(4)=%d\n",c[0][k],c[1][k],c[2][k],c[3][k],c[4][k]);
   */
}

int
maxx()
{
  int             k;
  int             opt = 0;
  /**** First maximum of vector x ***/
  for (k = 1; k <= Bsave; k++)
    if (x[k] > opt)
      opt = x[k];
  return (opt);
}

void
LUTcheck()
{
  int             uv, l, g, B2, improve = 0, i;
  int             newNOF[15], newSum, neu, gopt;

  B2 = B / 2;
  for (l = 1; l < B2; l += 2) {
    //Assume first the OF has the minimum Sum + cost
      uv = x[l];
    newSum = SumNof[l];
    neu = 0;
    for (i = 1; i < 9; i++)
      newNOF[i] = nof[l][i];

    //First find the cost and NOF sum minimum in the extfundarray
      g = l;
    while (g < B2) {
      g *= 2;
      if ((uv > x[g]) || ((x[g] == uv) && (newSum > SumNof[g]))) {
	uv = x[g];
	newSum = SumNof[g];
	gopt = g;
	for (i = 1; i < 9; i++)
	  newNOF[i] = nof[g][i];
      }
    }
    if (neu == 1) {
      printf("*** Check LUT : Divide required for %d/%d Cost=%d/%d SumNOF=%d/%d\n", l, gopt, uv, x[l], newSum, SumNof[l]);
      fprintf(fid, "*** Check LUT : Divide required for %d/%d Cost=%d/%d SumNOF=%d/%d\n", l, gopt, uv, x[g], newSum, SumNof[g]);
    }
    g = l;
    while (g < B) {		/** replace the one with less good costs/NOF sum ***/
      if ((uv < x[g]) || ((x[g] == uv) && (newSum < SumNof[g]))) {
	printf("***** Found LUT opt:l=%d g=%d new/old cost %d/%d Sum NOF= %d/%d\n", l, g, uv, x[g], newSum, SumNof[g]);
	x[g] = uv;
	SumNof[g] = newSum;
	for (i = 1; i < 9; i++)
	  nof[g][i] = newNOF[i];
	improve++;
      }
      g *= 2;
    }
  }
  printf("*** Check LUT nof done. Found %d improved.\n", improve);
  fprintf(fid, "*** Check LUT nof done. Found %d improved.\n", improve);
}

void
found(int g)
{
  int             k, j, iSum, size[G];
  double          Sum=0, avg=0;
  if (g >= Gmax) {
    printf("Index Overflow for g\n");
    exit(1);
  }
  sl[g] = 0;
  l[g] = 0;
  /**** First place postive then negative ***/
  for (k = 1; k <= B; k++)
    if (x[k] == g) {
      l[g]++;
      c[g][l[g]] = k;
      sl[g]++;
      if (l[g] >= (Cmax - 5)) {
	printf("Index Overflow sc\n");
	exit(1);
      }
      sc[g][sl[g]] = k;
    }
  for (k = 1; k <= B; k++)
    if (x[k] == g) {
      sl[g]++;
      sc[g][sl[g]] = -k;
    }
  printf("*** Found %d factors with costs %d\n", l[g], g);
  fprintf(fid, "*** Found %d factors with costs %d\n", l[g], g);
  printf("--------- Number of elements for : b=%d in B=%d out B=%d\n", b, B, Bsave);
  fprintf(fid,"--------- Number of elements for : b=%d in B=%d out B=%d\n", b, B, Bsave);
  /************ Compute array cost statistic **********/
  for (k = 0; k < G; k++)
    size[k] = 0;
  for (k = 0; k < Bsave; k++)
    if ((x[k] >= 0) && (x[k] < G))
      size[x[k]]++;
  for (k = 0; k < G; k++)
    if (size[k] > 0) {
      fprintf(fid, " l[%d]=%d ", k, size[k]);
      printf(" l[%d]=%d ", k, size[k]);
      Sum += l[k];
    }
  printf("\n*** Sum = %e\n", Sum);
  fprintf(fid, "\n*** Sum = %e\n", Sum);
  iSum = 0;
  for (k = 1; k <= Bsave; k++) {
    avg += SumNof[k];
    if (SumNof[k] > iSum) {
      iSum = SumNof[k];
      j = k;
    }
  }
  avg /= Bsave;
  printf("*** Maximum NOF Sum = %d for %d Average = %6.2f\n", iSum, j, avg);
  fprintf(fid, "*** Maximum NOF Sum = %d for %d Average = %6.2f\n", iSum, j, avg);
  printf("*** Input data: \n");
  fprintf(fid, "*** Input data: \n");
  for (k = 0; k < G; k++)
    if (org[k] > 0) {
      printf("cl[%d]=%d ", k, org[k]);
      fprintf(fid, "cl[%d]=%d ", k, org[k]);
    }
  printf("\n");
  fprintf(fid, "\n");
  printf("----Smalest entry per costs is at: \n");
  fprintf(fid, "----Smalest entry per costs is at: \n");
  for (k = 0; k < G; k++)
    if (l[k] > 0) {
      printf("%d  ", c[k][1]);
      fprintf(fid, "%d  ", c[k][1]);
    }
  printf("\n");
  fprintf(fid, "\n");


}
int
CSDload(int b)
{
  int             r, v, i, B, l;

  sprintf(DateiAlt, "csd%d.dat", b);
  sprintf(Datei, "nof%d.dat", b);
  stream = fopen(Datei, "r");
  if (stream == NULL) {
    /* fclose(stream); */
    printf("  New loading function including NOF : %s\n", DateiAlt);
    stream = fopen(DateiAlt, "r");
    if (stream == NULL) {
      printf("File %s does not exist !!!\n", DateiAlt);
      exit(1);
    }
  } else {
    printf("File %s already exist !!!\n", Datei);
    printf("Using precomputed MAG data \n");
  }
  /******* Datei CSD costs lesen und anzeigen  *************/
  /******* File has Cost, SumNof, nof array ****************/
  i = 0;
  l = -1;			/** linecounter l **/
  while (!feof(stream)) {
    fscanf(stream, "%s", Zeile);
    v = atoi(Zeile);
    l++;
    if (l == 11)
      l = 0;
    if (l == 0)
      i++;
    if (l == 0) {		/** first is cost entry **/
      if (i >= (Bmax - 5)) {
	printf("Array Overflow in load x");
	exit(1);
      }
      x[i] = v;
      if ((v >= 0) && (v < G)) {
	cl[x[i]]++;
	if (i <= Bsave)
	  org[v]++;
      } else
	x[i] = G - 2;
    }
    if (l == 1) {		/** second is Sum None output fundamental **/
      SumNof[i] = v;
    }
    if (l > 1) {		/** next are fundamentals **/
      nof[i][l - 1] = v;
    }
  }
  cl[x[i]]--;
  i--;
  B = i;
  printf("B= %d\n", B);
  fclose(stream);
  printf("*** Display of 5 lines of input file \n");
  /*for (r = B - 5; r < B; r++) {*/
  for (r = 1; r < 25; r++) {
    printf("row=%d:  c=%d Sum=%d  NOF=", r, x[r], SumNof[r]);
    for (l = 1; l < 10; l++)
      printf("%d ", nof[r][l]);
    printf("\n");
  }

  /******* Datei Posi CSD adds lesen und anzeigen  *************/
  sprintf(DateiAlt, "subs%d.dat", b);
  printf("  Loading: %s\n", DateiAlt);
  stream = fopen(DateiAlt, "r");
  if (stream == NULL) {
    printf("File %s does not exist !!!\n", DateiAlt);
    exit(1);
  }
  i = 0;
  while (!feof(stream)) {
    fscanf(stream, "%s", Zeile);
    i++;
    if (i >= (Bmax - 5)) {
      printf("Array Overflow in load subs");
      exit(1);
    }
    subs[i] = atoi(Zeile);
    if (i < 15) {
      printf("subs(%d)=%d", i, subs[i]);
    }
  }
  fclose(stream);

  printf("  End of LOAD! \n");
  return (B);
}				/****** Ende Laden ************/

/*************** Computes VHDL CSD of coefficient *************/
void
csdvhd(int Koeff)
{
  int             Posi = 0, Ops = 0;
  int             k, i, l, B[64], W[64];
  int             pow2;
  boolean         Start;


  for (l = 0; l < Bmax; l++)
    B[l] = 0;

  pow2 = 1;
  for (l = 0; pow2 <= Koeff; l++) {
    if (pow2 & Koeff)
      B[l] = 1;
    else
      B[l] = 0;
    pow2 <<= 1;
  }
  Start = FALSE;
  for (i = 2; i <= l; i++)
    if (Start)
      if (B[i] == 0) {
	B[i] = 1;
	Start = FALSE;
      } else
	B[i] = 0;
    else {
      if ((B[i] == 1) && (B[i - 1] == 1) && (B[i - 2] == 1)) {
	B[i - 2] = -1;
	B[i - 1] = 0;
	B[i] = 0;
	Start = TRUE;
      } else if ((B[i + 1] == 1) && (B[i] == 0) && (B[i - 1] == 1) && (B[i - 2] == 1)) {
	B[i - 2] = -1;
	B[i - 1] = 0;
	B[i] = 1;
      }
    }

  for (i = l; i >= 2; i--)
    if ((B[i] == 1) && (B[i - 1] == 0) && (B[i - 2] == -1)) {
      B[i - 2] = 1;
      B[i - 1] = 1;
      B[i] = 0;
    }
  for (i = l; i >= 0; i--) {
    if (B[i] > 0)
      Posi++;
    if (B[i] != 0)
      Ops++;
  }

  k = 0;
  for (i = 0; i <= l; i++) {
    if (B[i] > 0) {
      W[k] = 1 << i;
      k++;
    }
    if (B[i] < 0) {
      W[k] = -1 << i;
      k++;
    }
  }
  for (k = 0; k < Ops; k++) {
    if (abs(W[k]) == 1) {
      if (W[k] == 1)
	fprintf(stream, " x");
      else
	fprintf(stream, " - x");
    } else if (W[k] > 0)
      fprintf(stream, " + %d * x", W[k]);
    else
      fprintf(stream, " - %d * x", -W[k]);
  }
}

void
MAGsave(int b)
{
  int             Sum, n, k;
  //int           a;
  //boolean needcsd;
  char            op1[20];

  sprintf(DateiAlt, "mag%dl%d.dat", b, worklist);
  stream = fopen(DateiAlt, "w");
  printf("  Saving: %s with %d lines\n", DateiAlt, Bsave);
  for (n = 1; n <= B; n++) {
    fprintf(stream, "%d\n", x[n]);
  }
  fclose(stream);

  sprintf(DateiAlt, "nof%dl%d.dat", b, worklist);
  stream = fopen(DateiAlt, "w");
  printf("  Saving: %s with %d lines\n", DateiAlt, Bsave);
  for (n = 1; n <= B; n++) {
    fprintf(stream, "%d %d ", x[n], SumNof[n]);
    for (k = 1; k < 10; k++)
      fprintf(stream, "%d ", nof[n][k]);
    fprintf(stream, "\n");
  }
  fclose(stream);

  sprintf(DateiAlt, "magfac%dl%d.dat", b, worklist);
  stream = fopen(DateiAlt, "w");
  printf("  Saving: %s\n", DateiAlt);
  for (n = 1; n <= Bsave; n++) {
    Sum = 0;
    if (graph[n] == 0) {
      fprintf(stream, "x%d = %d ;\n", n, n);
      Sum = n;
    }
    if (graph[n] == 1) {
      fprintf(stream, "x%d = ", n);
      fprintf(stream, "%d ", nof4[0][n]);
      fprintf(stream, "+ %d ;\n", nof4[1][n]);
      Sum = nof4[0][n] + nof4[1][n];
    }
    if (graph[n] == 2) {
      fprintf(stream, "x%d = ", n);
      fprintf(stream, "%d ", nof4[0][n]);
      fprintf(stream, "- %d ;\n", -nof4[1][n]);
      Sum = nof4[0][n] + nof4[1][n];
    }
    if (graph[n] == 3) {
      fprintf(stream, "x%d = ", n);
      fprintf(stream, "%d ", nof4[0][n]);
      fprintf(stream, "* %d ;\n", nof4[1][n]);
      Sum = nof4[0][n] * nof4[1][n];
    }
    if (graph[n] > 3) {
      /* fprintf(stream, "graph > 3\n"); */
      if (nof4[1][n] > 0)
	sprintf(op1, "( %d + %d )", nof4[0][n], nof4[1][n]);
      else
	sprintf(op1, "( %d - %d )", nof4[0][n], -nof4[1][n]);
      Sum = nof4[0][n] + nof4[1][n];
      if (graph[n] == 5) {
	fprintf(stream, "x%d = %d * %s - %d ;\n", n, nof4[2][n], op1, -nof4[3][n]);
	Sum = nof4[3][n] + nof4[2][n] * Sum;
      }
      if (graph[n] == 4) {
	fprintf(stream, "x%d = %d * %s + %d ;\n", n, nof4[3][n], op1, nof4[2][n]);
	Sum = nof4[3][n] * Sum + nof4[2][n];
      }
    }
    if (Sum != n)
      fprintf(stream, "error for check !!!\n");
  }
  fclose(stream);

}


void
checkmul(int u, int v)
{
  int             i, k, g, k0, k1, improve = 0, NOFimprove = 0, of1, of2,
                  v1, v2;
  int             newsubs, uv, newSum, newNOF[15], NOFmax;
  double          v1d, v2d, gd;
  NOFmax = 1 << 14;
  uv = u + v;
  printf("******  %d Graph Cost_%d*Cost_%d\n", uv, u, v);
  fprintf(fid, "******  %d Graph Cost_%d*Cost_%d\n", uv, u, v);
  for (k0 = 1; k0 <= l[u]; k0++) {
    v1d = c[u][k0];
    v1 = (int) v1d;
    of1 = oddfund(v1);
//    if (of1 < NOFmax)
      for (k1 = 1; k1 <= l[v]; k1++) {
	v2d = c[v][k1];
	v2 = (int) v2d;
	gd = v1d * v2d;
	if ((gd < B) && (gd > 0)) {
	  g = v1 * v2;
	  of2 = oddfund(v2);
	  /*** new NOF is value + old sum ***/
	  for (i = 0; i <= 10; i++)
	    newNOF[i] = 0;
	  for (k = 1; k <= u; k++)
	    newNOF[k] = nof[v1][k];
	  for (i = 1; i <= v; i++) {
	    newNOF[k++] = oddfund(of1 * nof[v2][i]);
	  }

	  newSum = 0;
	  for (k = 1; k < uv; k++)
	    newSum += newNOF[k];

	  if ((g < B) && (g > 0))
	    if ((x[g] > uv) || ((x[g] == uv) && (newSum < SumNof[g]))) {
	      if ((x[g] == uv) && (g <= Bsave))
		NOFimprove++;
	      if ((x[g] > uv) && (g <= Bsave))
		improve++;

	      if (g == Test) {
		printf("g = %d OldSum=%d  newSum=%d\n", g, SumNof[g], newSum);
		printf("v1=%d v2=%d SumNof[%d]= %d SumNof[%d]=%d\n", v1, v2, v1, SumNof[v1], v2, SumNof[v2]);
		adisp("Guess new NOF: ", newNOF, 10);
	      }
	      //if (x[g] > uv)
		fprintf(fid, "%d = %d * %d \n", g, v1, v2);
	      x[g] = uv;
	      nof4[0][g] = v1;
	      nof4[1][g] = v2;
	      fct[1][g] = u;
	      fct[0][g] = v;
	      graph[g] = 3;
	      subs[g] = newsubs;
	      sort(newNOF, uv);
	      /** use as new OF array **/
	      for (i = 1; i < 9; i++)
		nof[g][i] = newNOF[i];
	      SumNof[g] = newSum;
	      if (g == Test) {
		printf("new Mul: cost=%d: %d=%d * (%d) SumNOF= %d\n", uv, g, v1, v2, newSum);
		adisp("new NOF", newNOF, 10);
	      }
	    }
	}
      }
  }
  if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove  %d Graph Cost_%d*Cost_%d No Improvements\n", uv, u, v);
    fprintf(fid, "****** Remove %d Graph Cost_%d*Cost_%d No Improvements\n", uv, u, v);
  } else {
    printf("****** Use %d Graph Cost_%d*Cost_%d ", uv, u, v);
    fprintf(fid, "****** Use %d Graph Cost_%d*Cost_%d ", uv, u, v);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
}

void
checkadd(int u, int v)
{
  int             uv2, uv1, v1, v2, g, k1, k2, improve = 0, NOFimprove = 0,
                  uk2, k, i, of1, of2;
  int             newsubs, uv, newSum, newNOF[15];

  uv = u + v + 1;
  printf("******  %d Graph Cost_%d+/-Cost_%d\n", uv, u, v);
  fprintf(fid, "******  %d Graph Cost_%d+/-Cost_%d\n", uv, u, v);
  for (k1 = 1; k1 <= l[u]; k1++)
    for (k2 = 1; k2 <= sl[v]; k2++) {
      v1 = (int) sc[u][k1];
      uv1 = abs(v1);
      v2 = (int) sc[v][k2];
      uv2 = abs(v2);
      g = abs(v1 + v2);
      uk2 = k2;
      if (sc[v][k2] > 0) {
	newsubs = subs[v1] + subs[uv2];
      } else {
	newsubs = subs[v1] + subs[uv2] - 1;
	uk2 -= l[v];
      }

      of1 = oddfund(v1);
      of2 = oddfund(uv2);
      if (of1 == 1)
	of1 = 0;
      if (of2 == 1)
	of2 = 0;

      newSum = SumNof[v1] + SumNof[uv2] + of1 + of2;
      if ((g < B) && (g > 0))
	if ((x[g] > uv) || ((x[g] == uv) && (abs(newSum) < SumNof[g]))) {
	  if ((x[g] == uv) && (g <= Bsave))
	    NOFimprove++;
	  if ((x[g] > uv) && (g <= Bsave))
	    improve++;

	  if (g == Test) {
	    printf("g = %d OldSum=%d  newSum=%d\n", g, SumNof[g], newSum);
	    printf("v1=%d uv2=%d SumNof[%d]= %d SumNof[%d]=%d\n", v1, uv2, v1, SumNof[v1], uv2, SumNof[uv2]);
	  }			/** new NOF array is sum from both arrays **/
	  for (i = 0; i <= 10; i++)
	    newNOF[i] = 0;
	  for (k = 1; k <= u; k++)
	    newNOF[k] = nof[uv1][k];
	  for (i = 1; i <= v; i++) {
	    newNOF[k] = nof[uv2][i];
	    k++;
	  }
	  newNOF[k] = oddfund(g);
	  /** sort array but leave g at last position **/
	  sort(newNOF, uv - 1);
	  /** use as new OF array **/
	  for (i = 1; i < 9; i++)
	    nof[g][i] = newNOF[i];
	  /*** only for cost 1+1 ***/
	  /* nof[g][1]=of1;nof[g][2]=of2; */
	  if (g == Test) {
	    printf("new cost=%d old cost=%d: %d=%d+(%d) SumNOF= %d\n", uv, x[g], g, v1, v2, newSum);
	    adisp("new NOF", newNOF, 10);
	  }
	  if ((v1 + v2) < 0) {
	    nof4[1][g] = -c[u][k1];
	    nof4[0][g] = (int) -sc[v][k2];
	    //if (x[g] > uv)
	      fprintf(fid, "%d = %d %+d\n", g, -sc[v][k2], -c[u][k1]);
	    fct[1][g] = u;
	    fct[0][g] = v;
	  } else {
	    nof4[0][g] = c[u][k1];
	    nof4[1][g] = (int) sc[v][k2];
	    //if (x[g] > uv)
	      fprintf(fid, "%d = %d  %+d\n", g, c[u][k1], sc[v][k2]);
	    fct[0][g] = u;
	    fct[1][g] = v;
	  }
	  SumNof[g] = newSum;
	  x[g] = uv;
	  if (sc[v][k2] > 0)
	    graph[g] = 1;
	  else
	    graph[g] = 2;
	  subs[g] = newsubs;
	}
    }
  if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove  %d Graph Cost_%d+/-Cost_%d No Improvements\n", uv, u, v);
    fprintf(fid, "****** Remove %d Graph Cost_%d+/-Cost_%d No Improvements\n", uv, u, v);
  } else {
    printf("****** Use %d Graph Cost_%d+/-Cost_%d ", uv, u, v);
    fprintf(fid, "****** Use %d Graph Cost_%d+/-Cost_%d ", uv, u, v);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
}

#include  "magwl.c"

int
main()
{
  int             Sum = 0, k, j, i, k1;
  int             g, NOFmax, kmax, imax;
  float           avg = 0.0;
  boolean         dogencost = TRUE;

  time(&t0);
  t1 = t0;
  printf("Define mag table bit width =\n");
  scanf("%d", &b);
  printf("Define worklist file =\n");
  scanf("%d", &worklist);

  Bmax = (1 << (b + 1)) + 10;
  Bsave = 1 << b;
  /***** define the cost function **/
  if ((x = (int *) calloc(Bmax, sizeof(int))) == NULL) {
    printf("Not enough memory for array %s available\n", "x");
    exit(1);
  }
  /***** define the number of subs **/
  if ((subs = (int *) calloc(Bmax, sizeof(int))) == NULL) {
    printf("Not enough memory for array %s available\n", "subs");
    exit(1);
  }
  /***** define the sum of NOFs **/
  if ((SumNof = (int *) calloc(Bmax, sizeof(int))) == NULL) {
    printf("Not enough memory for array %s available\n", "SumNof");
    exit(1);
  }
  /** none output fundamentals list ***/
  nof = (int **) calloc(Bmax, sizeof(int));
  for (j = 0; j <= Bmax; j++) {
    nof[j] = (int *) calloc(10 + 1, sizeof(int));
    if (nof == NULL)
      fatal("nof");
  }

  B = CSDload(b);
  Gmax = (int) ceil(maxx()) + 3;
  if (Gmax >= G) {
    printf("Gmax to small\n");
    exit(1);
  }
  Cmax = Bmax;
  sprintf(DateiAlt, "mag%dl%d.pro", b, worklist);
  fid = fopen(DateiAlt, "w");
  k = getarrays();

  find(0);
  for (k1 = 0; k1 <= b; k1++) {
    g = (int) floor(pow(2.0, (double) k1) + .1);
    x[g] = 0;
  }
  found(0);


printf("--------- Number of elements for : b=%d in B=%d out B=%d\n", b, B, Bsave);
  fprintf(fid, "--------- Number of elements for : b=%d in B=%d out B=%d\n", b, B, Bsave);
  for (k = 0; k < G; k++)
    l[k] = 0;
  for (k = 0; k < Bsave; k++)
    if ((x[k] >= 0) && (x[k] < G))
      l[x[k]]++;
  for (k = 0; k < G; k++)
    if (l[k] > 0) {
      fprintf(fid, " l[%d]=%d ", k, l[k]);
      printf(" l[%d]=%d ", k, l[k]);
      Sum += l[k];
    }
  printf("\n*** Sum = %d\n", Sum);
  fprintf(fid, "\n*** Sum = %d\n", Sum);
  Sum = 0;
  for (k = 1; k <= Bsave; k++) {
    avg += SumNof[k];
    if (SumNof[k] > Sum) {
      Sum = SumNof[k];
      j = k;
    }
  }
  avg /= Bsave;
  printf("*** Maximum NOF Sum = %d for %d Average = %6.2f\n", Sum, j, avg);
  fprintf(fid, "*** Maximum NOF Sum = %d for %d Average = %6.2f\n", Sum, j, avg);
  printf("*** Input data: \n");
  fprintf(fid, "*** Input data: \n");
  for (k = 0; k < G; k++)
    if (org[k] > 0) {
      printf("cl[%d]=%d ", k, org[k]);
      fprintf(fid, "cl[%d]=%d ", k, org[k]);
    }
  printf("\n");
  fprintf(fid, "\n");
  printf("----Smalest entry per costs is at: \n");
  fprintf(fid, "----Smalest entry per costs is at: \n");
  for (k = 0; k < G; k++)
    if (l[k] > 0) {
      printf("%d  ", c[k][1]);
      fprintf(fid, "%d  ", c[k][1]);
    }
  printf("\n");
  fprintf(fid, "\n");

  Nr = loadWorklist(worklist);
  for (i = 0; i <= Nr; i++) {
    Treffer = FALSE;
    if ((T[i][0] == 'a') && (T[i][1] == 'd') && (T[i][2] == 'd')) {
      checkadd(wl[i][1], wl[i][2]);
      LUTcheck();
      Treffer = TRUE;
    }
    if ((T[i][0] == 'm') && (T[i][1] == 'u') && (T[i][2] == 'l')) {
      checkmul(wl[i][1], wl[i][2]);
      Treffer = TRUE;
    }
    if (T[i][0] == '*') {
      Treffer = TRUE;
    }
    if ((T[i][0] == 'f') && (T[i][1] == 'i') && (T[i][2] == 'n')) {
      found(wl[i][1] - 1);
      find(wl[i][1]);
      Treffer = TRUE;
    }
    if ((T[i][0] == 'c')&& (T[i][1] == 'h')) {
      LUTcheck();
      Treffer = TRUE;
    }
    if ((T[i][0] == 'c') && ((T[i][1] == '3') || (T[i][1] == '1')|| (T[i][1] == '2')|| (T[i][1] == '4') ||(T[i][1] == '5'))) {
      if (dogencost) {
      gencost();
      dogencost=FALSE;
      }
      Treffer = TRUE;
    }
    if (T[i][0] == 's') {
      MAGsave(b);
      Treffer = TRUE;
    }
    /*t1 = t2;
    time(&t2);
    printf("Time this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
    fprintf(fid, "Time this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));*/
    if (Treffer == FALSE) {
      printf("\n Modul %c%c%c does not exits !!!\n", T[i][0], T[i][1], T[i][2]);
      exit(1);
    }
  }
  time(&t2);
  printf("Total worklist Comp. Time=  %f sec.\n", difftime(t2, t0));
  fprintf(fid, "Total worklist Comp. Time=  %f sec.\n", difftime(t2, t0));
  NOFmax = 0;			/**** Compute Maximum NOF **/
  for (k = 1; k < Bsave; k++)
    for (i = 1; i < x[k]; i++)
      if (nof[k][i] > NOFmax) {
	NOFmax = nof[k][i];
	kmax = k;
	imax = i;
      }
  printf("****** NOFmax= %d k=%d,i=%d\n", NOFmax, kmax, imax);

  fclose(fid);
  return 0;
}