void gencost()
{
  int             k0, k2, k3, k4, k5;
  int             cost, g, improve, NOFimprove, NOFmax;
  int             i, k, newSum, newNOF[15];
  int             of1, of2, of3, of4, of5;
  int             k6, k7;
  double          v6d, v7d, f4d;
  int             k8, k9;
  double          v8d, v9d, f5d;
  double          loops, f1d, f2d, f3d, gd;
  double          v2d, v3d, v4d, v5d;
  printf("****** l[0]=%d  sl[0]=%d\n", l[0],sl[0]);
  printf("****** l[1]=%d  sl[1]=%d\n", l[1],sl[1]);
  printf("****** l[2]=%d  sl[2]=%d\n", l[2],sl[2]);
  printf("****** l[3]=%d  sl[3]=%d\n", l[3],sl[3]);
  checkadd(0, 0); LUTcheck();found(1);
  /************ Compute cost 1 odd array **********/
  slone=0;
  for (k = 1; k <= sl[1]; k++)
   if (( abs( (int) sc[1][k]) % 2) == 1) { /** cost 1 is odd **/
     slone++;
    scone[slone] = sc[1][k];
  }
 printf("---111 Number of odd cost 1 : %d \n", slone);
 fprintf(fid, "---111 Number of elements for : %d \n", slone);

 found(0);//****** function call find

 find(1);
  
  //**** c1 only one graph
  checkadd(0, 0);

 LUTcheck();//****** function call check

 found(1);//****** function call find

 find(2);

/*************** Next Graph Info *************************/
//******** cost 2 = (0,0)(0,1)
//******** Fan-out: 0=3; 1=1; 2=0; 
  printf("//*** 1) cost 2 = (0,0)(0,1)\n");
  fprintf(fid, "//*** 1) cost 2 = (0,0)(0,1)\n");
 cost = 2;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  g = (int) f2d; loops+=1; /** output fundamental **/
  gd = f2d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = oddfund((int) f2d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  0) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 0) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 0) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 0) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));


/*************** Next Graph Info *************************/
//******** cost 2 = (0,0)(1,1)
//******** Fan-out: 0=2; 1=2; 2=0; 
  printf("//*** 2) cost 2 = (0,0)(1,1)\n");
  fprintf(fid, "//*** 2) cost 2 = (0,0)(1,1)\n");
 cost = 2;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  g = (int) f2d; loops+=1; /** output fundamental **/
  gd = f2d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = oddfund((int) f2d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  0) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 0) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 0) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 0) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));


 LUTcheck();//****** function call check

 found(2);//****** function call find

 find(3);

/*************** Next Graph Info *************************/
//******** cost 3 = (0,0)(0,1)(0,2)
//******** Fan-out: 0=4; 1=1; 2=1; 3=0; 
  printf("//*** 1) cost 3 = (0,0)(0,1)(0,2)\n");
  fprintf(fid,"//*** 1) cost 3 = (0,0)(0,1)(0,2)\n");
 cost = 3;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  g = (int) f3d; loops+=1; /** output fundamental **/
  gd = f3d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = oddfund((int) f3d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  1) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 1) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 1) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 1) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));


/*************** Next Graph Info *************************/
//******** cost 3 = (0,0)(0,1)(1,2)
//******** Fan-out: 0=3; 1=2; 2=1; 3=0; 
  printf("//*** 2) cost 3 = (0,0)(0,1)(1,2)\n");
  fprintf(fid,"//*** 2) cost 3 = (0,0)(0,1)(1,2)\n");
 cost = 3;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  g = (int) f3d; loops+=1; /** output fundamental **/
  gd = f3d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = oddfund((int) f3d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  2) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 2) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 2) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 2) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));


/*************** Next Graph Info *************************/
//******** cost 3 = (0,0)(0,1)(2,2)
//******** Fan-out: 0=3; 1=1; 2=2; 3=0; 
  printf("//*** 3) cost 3 = (0,0)(0,1)(2,2)\n");
  fprintf(fid,"//*** 3) cost 3 = (0,0)(0,1)(2,2)\n");
 cost = 3;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  g = (int) f3d; loops+=1; /** output fundamental **/
  gd = f3d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = oddfund((int) f3d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  3) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 3) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 3) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 3) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));


/*************** Next Graph Info *************************/
//******** cost 3 = (0,0)(1,1)(0,2)
//******** Fan-out: 0=3; 1=2; 2=1; 3=0; 
  printf("//*** 4) cost 3 = (0,0)(1,1)(0,2)\n");
  fprintf(fid,"//*** 4) cost 3 = (0,0)(1,1)(0,2)\n");
 cost = 3;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  g = (int) f3d; loops+=1; /** output fundamental **/
  gd = f3d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = oddfund((int) f3d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  4) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 4) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 4) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 4) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));


/*************** Next Graph Info *************************/
//******** cost 3 = (0,0)(1,1)(1,2)
//******** Fan-out: 0=2; 1=3; 2=1; 3=0; 
  printf("//*** 5) cost 3 = (0,0)(1,1)(1,2)\n");
  fprintf(fid,"//*** 5) cost 3 = (0,0)(1,1)(1,2)\n");
 cost = 3;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  g = (int) f3d; loops+=1; /** output fundamental **/
  gd = f3d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = oddfund((int) f3d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  5) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 5) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 5) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 5) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));


/*************** Next Graph Info *************************/
//******** cost 3 = (0,0)(1,1)(2,2)
//******** Fan-out: 0=2; 1=2; 2=2; 3=0; 
  printf("//*** 6) cost 3 = (0,0)(1,1)(2,2)\n");
  fprintf(fid,"//*** 6) cost 3 = (0,0)(1,1)(2,2)\n");
 cost = 3;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  g = (int) f3d; loops+=1; /** output fundamental **/
  gd = f3d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = oddfund((int) f3d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  6) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 6) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 6) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 6) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));


/*************** Next Graph Info *************************/
//******** cost 3 = (0,0)(0,0)(1,2)
//******** Fan-out: 0=4; 1=1; 2=1; 3=0; 
  printf("//*** 7) cost 3 = (0,0)(0,0)(1,2)\n");
  fprintf(fid,"//*** 7) cost 3 = (0,0)(0,0)(1,2)\n");
 cost = 3;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  { //*** no loop since fanout=1 for node=1
  { //*** no loop since fanout=1 for node=2
    f3d =  f1d;
    f3d += f2d;
  g = (int) f3d; loops+=1; /** output fundamental **/
  gd = f3d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = oddfund((int) f3d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  7) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 7) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 7) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 7) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));


 LUTcheck();//****** function call check

 found(3);//****** function call find

 find(4);

/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(0,0)(1,2)(0,3)
//******** Fan-out: 0=5; 1=1; 2=1; 3=1; 4=0; 
  printf("//*** 1) cost 4 = (0,0)(0,0)(1,2)(0,3)\n");
  fprintf(fid,"//*** 1) cost 4 = (0,0)(0,0)(1,2)(0,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  { //*** no loop since fanout=1 for node=1
  { //*** no loop since fanout=1 for node=2
    f3d =  f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  1) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 1) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 1) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 1) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 0 0 1 2 0 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 0 0 1 2 0 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(0,1)(0,0)(2,3)
//******** Fan-out: 0=5; 1=1; 2=1; 3=1; 4=0; 
  printf("//*** 2) cost 4 = (0,0)(0,1)(0,0)(2,3)\n");
  fprintf(fid,"//*** 2) cost 4 = (0,0)(0,1)(0,0)(2,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4];
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  2) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 2) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 2) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 2) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 0 1 0 0 2 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 0 1 0 0 2 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(0,1)(0,2)(0,3)
//******** Fan-out: 0=5; 1=1; 2=1; 3=1; 4=0; 
  printf("//*** 3) cost 4 = (0,0)(0,1)(0,2)(0,3)\n");
  fprintf(fid,"//*** 3) cost 4 = (0,0)(0,1)(0,2)(0,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  3) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 3) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 3) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 3) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 0 1 0 2 0 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 0 1 0 2 0 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(0,0)(1,2)(1,3)
//******** Fan-out: 0=4; 1=2; 2=1; 3=1; 4=0; 
  printf("//*** 4) cost 4 = (0,0)(0,0)(1,2)(1,3)\n");
  fprintf(fid,"//*** 4) cost 4 = (0,0)(0,0)(1,2)(1,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  4) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 4) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 4) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 4) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 0 0 1 2 1 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 0 0 1 2 1 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(0,0)(1,2)(3,3)
//******** Fan-out: 0=4; 1=1; 2=1; 3=2; 4=0; 
  printf("//*** 5) cost 4 = (0,0)(0,0)(1,2)(3,3)\n");
  fprintf(fid,"//*** 5) cost 4 = (0,0)(0,0)(1,2)(3,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  { //*** no loop since fanout=1 for node=1
  { //*** no loop since fanout=1 for node=2
    f3d =  f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  5) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 5) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 5) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 5) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 0 0 1 2 3 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 0 0 1 2 3 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(0,1)(0,1)(2,3)
//******** Fan-out: 0=4; 1=2; 2=1; 3=1; 4=0; 
  printf("//*** 6) cost 4 = (0,0)(0,1)(0,1)(2,3)\n");
  fprintf(fid,"//*** 6) cost 4 = (0,0)(0,1)(0,1)(2,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  6) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 6) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 6) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 6) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 0 1 0 1 2 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 0 1 0 1 2 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(0,1)(0,2)(1,3)
//******** Fan-out: 0=4; 1=2; 2=1; 3=1; 4=0; 
  printf("//*** 7) cost 4 = (0,0)(0,1)(0,2)(1,3)\n");
  fprintf(fid,"//*** 7) cost 4 = (0,0)(0,1)(0,2)(1,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  7) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 7) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 7) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 7) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 0 1 0 2 1 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 0 1 0 2 1 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(0,1)(0,2)(2,3)
//******** Fan-out: 0=4; 1=1; 2=2; 3=1; 4=0; 
  printf("//*** 8) cost 4 = (0,0)(0,1)(0,2)(2,3)\n");
  fprintf(fid,"//*** 8) cost 4 = (0,0)(0,1)(0,2)(2,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  8) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 8) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 8) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 8) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 0 1 0 2 2 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 0 1 0 2 2 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(0,1)(0,2)(3,3)
//******** Fan-out: 0=4; 1=1; 2=1; 3=2; 4=0; 
  printf("//*** 9) cost 4 = (0,0)(0,1)(0,2)(3,3)\n");
  fprintf(fid,"//*** 9) cost 4 = (0,0)(0,1)(0,2)(3,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  9) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 9) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 9) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 9) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 0 1 0 2 3 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 0 1 0 2 3 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(0,1)(1,1)(2,3)
//******** Fan-out: 0=3; 1=3; 2=1; 3=1; 4=0; 
  printf("//*** 10) cost 4 = (0,0)(0,1)(1,1)(2,3)\n");
  fprintf(fid,"//*** 10) cost 4 = (0,0)(0,1)(1,1)(2,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  10) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 10) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 10) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 10) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 0 1 1 1 2 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 0 1 1 1 2 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(0,1)(1,2)(0,3)
//******** Fan-out: 0=4; 1=2; 2=1; 3=1; 4=0; 
  printf("//*** 11) cost 4 = (0,0)(0,1)(1,2)(0,3)\n");
  fprintf(fid,"//*** 11) cost 4 = (0,0)(0,1)(1,2)(0,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  11) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 11) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 11) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 11) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 0 1 1 2 0 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 0 1 1 2 0 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(0,1)(1,2)(1,3)
//******** Fan-out: 0=3; 1=3; 2=1; 3=1; 4=0; 
  printf("//*** 12) cost 4 = (0,0)(0,1)(1,2)(1,3)\n");
  fprintf(fid,"//*** 12) cost 4 = (0,0)(0,1)(1,2)(1,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  12) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 12) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 12) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 12) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 0 1 1 2 1 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 0 1 1 2 1 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(0,1)(2,2)(0,3)
//******** Fan-out: 0=4; 1=1; 2=2; 3=1; 4=0; 
  printf("//*** 13) cost 4 = (0,0)(0,1)(2,2)(0,3)\n");
  fprintf(fid,"//*** 13) cost 4 = (0,0)(0,1)(2,2)(0,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  13) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 13) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 13) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 13) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 0 1 2 2 0 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 0 1 2 2 0 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(0,1)(2,2)(2,3)
//******** Fan-out: 0=3; 1=1; 2=3; 3=1; 4=0; 
  printf("//*** 14) cost 4 = (0,0)(0,1)(2,2)(2,3)\n");
  fprintf(fid,"//*** 14) cost 4 = (0,0)(0,1)(2,2)(2,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  14) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 14) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 14) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 14) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 0 1 2 2 2 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 0 1 2 2 2 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(1,1)(0,0)(2,3)
//******** Fan-out: 0=4; 1=2; 2=1; 3=1; 4=0; 
  printf("//*** 15) cost 4 = (0,0)(1,1)(0,0)(2,3)\n");
  fprintf(fid,"//*** 15) cost 4 = (0,0)(1,1)(0,0)(2,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4];
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  15) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 15) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 15) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 15) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 1 1 0 0 2 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 1 1 0 0 2 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(1,1)(0,2)(0,3)
//******** Fan-out: 0=4; 1=2; 2=1; 3=1; 4=0; 
  printf("//*** 16) cost 4 = (0,0)(1,1)(0,2)(0,3)\n");
  fprintf(fid,"//*** 16) cost 4 = (0,0)(1,1)(0,2)(0,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  16) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 16) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 16) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 16) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 1 1 0 2 0 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 1 1 0 2 0 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(1,1)(0,2)(1,3)
//******** Fan-out: 0=3; 1=3; 2=1; 3=1; 4=0; 
  printf("//*** 17) cost 4 = (0,0)(1,1)(0,2)(1,3)\n");
  fprintf(fid,"//*** 17) cost 4 = (0,0)(1,1)(0,2)(1,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  17) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 17) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 17) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 17) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 1 1 0 2 1 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 1 1 0 2 1 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(1,1)(1,1)(2,3)
//******** Fan-out: 0=2; 1=4; 2=1; 3=1; 4=0; 
  printf("//*** 18) cost 4 = (0,0)(1,1)(1,1)(2,3)\n");
  fprintf(fid,"//*** 18) cost 4 = (0,0)(1,1)(1,1)(2,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  18) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 18) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 18) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 18) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 1 1 1 1 2 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 1 1 1 1 2 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(1,1)(1,2)(0,3)
//******** Fan-out: 0=3; 1=3; 2=1; 3=1; 4=0; 
  printf("//*** 19) cost 4 = (0,0)(1,1)(1,2)(0,3)\n");
  fprintf(fid,"//*** 19) cost 4 = (0,0)(1,1)(1,2)(0,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  19) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 19) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 19) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 19) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 1 1 1 2 0 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 1 1 1 2 0 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(1,1)(1,2)(1,3)
//******** Fan-out: 0=2; 1=4; 2=1; 3=1; 4=0; 
  printf("//*** 20) cost 4 = (0,0)(1,1)(1,2)(1,3)\n");
  fprintf(fid,"//*** 20) cost 4 = (0,0)(1,1)(1,2)(1,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  20) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 20) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 20) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 20) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 1 1 1 2 1 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 1 1 1 2 1 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(0,1)(1,2)(2,3)
//******** Fan-out: 0=3; 1=2; 2=2; 3=1; 4=0; 
  printf("//*** 21) cost 4 = (0,0)(0,1)(1,2)(2,3)\n");
  fprintf(fid,"//*** 21) cost 4 = (0,0)(0,1)(1,2)(2,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  21) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 21) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 21) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 21) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 0 1 1 2 2 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 0 1 1 2 2 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(0,1)(1,2)(3,3)
//******** Fan-out: 0=3; 1=2; 2=1; 3=2; 4=0; 
  printf("//*** 22) cost 4 = (0,0)(0,1)(1,2)(3,3)\n");
  fprintf(fid,"//*** 22) cost 4 = (0,0)(0,1)(1,2)(3,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  22) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 22) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 22) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 22) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 0 1 1 2 3 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 0 1 1 2 3 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(0,1)(2,2)(1,3)
//******** Fan-out: 0=3; 1=2; 2=2; 3=1; 4=0; 
  printf("//*** 23) cost 4 = (0,0)(0,1)(2,2)(1,3)\n");
  fprintf(fid,"//*** 23) cost 4 = (0,0)(0,1)(2,2)(1,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  23) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 23) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 23) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 23) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 0 1 2 2 1 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 0 1 2 2 1 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(0,1)(2,2)(3,3)
//******** Fan-out: 0=3; 1=1; 2=2; 3=2; 4=0; 
  printf("//*** 24) cost 4 = (0,0)(0,1)(2,2)(3,3)\n");
  fprintf(fid,"//*** 24) cost 4 = (0,0)(0,1)(2,2)(3,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  24) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 24) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 24) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 24) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 0 1 2 2 3 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 0 1 2 2 3 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(1,1)(0,2)(2,3)
//******** Fan-out: 0=3; 1=2; 2=2; 3=1; 4=0; 
  printf("//*** 25) cost 4 = (0,0)(1,1)(0,2)(2,3)\n");
  fprintf(fid,"//*** 25) cost 4 = (0,0)(1,1)(0,2)(2,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  25) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 25) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 25) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 25) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 1 1 0 2 2 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 1 1 0 2 2 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(1,1)(0,2)(3,3)
//******** Fan-out: 0=3; 1=2; 2=1; 3=2; 4=0; 
  printf("//*** 26) cost 4 = (0,0)(1,1)(0,2)(3,3)\n");
  fprintf(fid,"//*** 26) cost 4 = (0,0)(1,1)(0,2)(3,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  26) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 26) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 26) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 26) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 1 1 0 2 3 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 1 1 0 2 3 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(1,1)(1,2)(2,3)
//******** Fan-out: 0=2; 1=3; 2=2; 3=1; 4=0; 
  printf("//*** 27) cost 4 = (0,0)(1,1)(1,2)(2,3)\n");
  fprintf(fid,"//*** 27) cost 4 = (0,0)(1,1)(1,2)(2,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  27) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 27) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 27) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 27) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 1 1 1 2 2 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 1 1 1 2 2 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(1,1)(1,2)(3,3)
//******** Fan-out: 0=2; 1=3; 2=1; 3=2; 4=0; 
  printf("//*** 28) cost 4 = (0,0)(1,1)(1,2)(3,3)\n");
  fprintf(fid,"//*** 28) cost 4 = (0,0)(1,1)(1,2)(3,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  28) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 28) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 28) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 28) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 1 1 1 2 3 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 1 1 1 2 3 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(1,1)(2,2)(0,3)
//******** Fan-out: 0=3; 1=2; 2=2; 3=1; 4=0; 
  printf("//*** 29) cost 4 = (0,0)(1,1)(2,2)(0,3)\n");
  fprintf(fid,"//*** 29) cost 4 = (0,0)(1,1)(2,2)(0,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  29) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 29) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 29) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 29) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 1 1 2 2 0 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 1 1 2 2 0 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(1,1)(2,2)(1,3)
//******** Fan-out: 0=2; 1=3; 2=2; 3=1; 4=0; 
  printf("//*** 30) cost 4 = (0,0)(1,1)(2,2)(1,3)\n");
  fprintf(fid,"//*** 30) cost 4 = (0,0)(1,1)(2,2)(1,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  30) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 30) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 30) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 30) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 1 1 2 2 1 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 1 1 2 2 1 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(1,1)(2,2)(2,3)
//******** Fan-out: 0=2; 1=2; 2=3; 3=1; 4=0; 
  printf("//*** 31) cost 4 = (0,0)(1,1)(2,2)(2,3)\n");
  fprintf(fid,"//*** 31) cost 4 = (0,0)(1,1)(2,2)(2,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  31) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 31) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 31) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 31) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 1 1 2 2 2 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 1 1 2 2 2 3 sort4\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 4 = (0,0)(1,1)(2,2)(3,3)
//******** Fan-out: 0=2; 1=2; 2=2; 3=2; 4=0; 
  printf("//*** 32) cost 4 = (0,0)(1,1)(2,2)(3,3)\n");
  fprintf(fid,"//*** 32) cost 4 = (0,0)(1,1)(2,2)(3,3)\n");
 cost = 4;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  g = (int) f4d; loops+=1; /** output fundamental **/
  gd = f4d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = oddfund((int) f4d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  32) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 32) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 32) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 32) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c4 0 0 1 1 2 2 3 3 sort4\n", difftime(t2, t1));
  fprintf(fid,"%07.1f c4  0 0 1 1 2 2 3 3 sort4\n",difftime(t2, t1));


 LUTcheck();//****** function call check

 found(4);//****** function call find

 find(5);

/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(0,1)(2,3)(0,4)
//******** Fan-out: 0=6; 1=1; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 1) cost 5 = (0,0)(0,0)(0,1)(2,3)(0,4)\n");
  fprintf(fid,"//*** 1) cost 5 = (0,0)(0,0)(0,1)(2,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=1
    f3d = v4d;
    f3d += f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  1) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 1) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 1) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 1) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 0 1 2 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 0 1 2 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,2)(0,0)(3,4)
//******** Fan-out: 0=6; 1=1; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 2) cost 5 = (0,0)(0,0)(1,2)(0,0)(3,4)\n");
  fprintf(fid,"//*** 2) cost 5 = (0,0)(0,0)(1,2)(0,0)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  { //*** no loop since fanout=1 for node=1
  { //*** no loop since fanout=1 for node=2
    f3d =  f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6];
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  2) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 2) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 2) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 2) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 2 0 0 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 2 0 0 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,2)(0,3)(0,4)
//******** Fan-out: 0=6; 1=1; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 3) cost 5 = (0,0)(0,0)(1,2)(0,3)(0,4)\n");
  fprintf(fid,"//*** 3) cost 5 = (0,0)(0,0)(1,2)(0,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  { //*** no loop since fanout=1 for node=1
  { //*** no loop since fanout=1 for node=2
    f3d =  f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  3) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 3) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 3) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 3) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 2 0 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 2 0 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,0)(0,3)(2,4)
//******** Fan-out: 0=6; 1=1; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 4) cost 5 = (0,0)(0,1)(0,0)(0,3)(2,4)\n");
  fprintf(fid,"//*** 4) cost 5 = (0,0)(0,1)(0,0)(0,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4];
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=4
    f5d =  f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  4) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 4) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 4) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 4) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 0 0 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 0 0 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(0,0)(3,4)
//******** Fan-out: 0=6; 1=1; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 5) cost 5 = (0,0)(0,1)(0,2)(0,0)(3,4)\n");
  fprintf(fid,"//*** 5) cost 5 = (0,0)(0,1)(0,2)(0,0)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6];
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  5) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 5) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 5) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 5) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 0 0 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 0 0 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(0,3)(0,4)
//******** Fan-out: 0=6; 1=1; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 6) cost 5 = (0,0)(0,1)(0,2)(0,3)(0,4)\n");
  fprintf(fid,"//*** 6) cost 5 = (0,0)(0,1)(0,2)(0,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  6) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 6) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 6) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 6) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 0 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 0 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(0,1)(2,3)(1,4)
//******** Fan-out: 0=5; 1=2; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 7) cost 5 = (0,0)(0,0)(0,1)(2,3)(1,4)\n");
  fprintf(fid,"//*** 7) cost 5 = (0,0)(0,0)(0,1)(2,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  7) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 7) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 7) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 7) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 0 1 2 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 0 1 2 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(0,1)(2,3)(4,4)
//******** Fan-out: 0=5; 1=1; 2=1; 3=1; 4=2; 5=0; 
  printf("//*** 8) cost 5 = (0,0)(0,0)(0,1)(2,3)(4,4)\n");
  fprintf(fid,"//*** 8) cost 5 = (0,0)(0,0)(0,1)(2,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=1
    f3d = v4d;
    f3d += f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  8) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 8) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 8) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 8) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 0 1 2 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 0 1 2 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(0,2)(1,3)(1,4)
//******** Fan-out: 0=5; 1=2; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 9) cost 5 = (0,0)(0,0)(0,2)(1,3)(1,4)\n");
  fprintf(fid,"//*** 9) cost 5 = (0,0)(0,0)(0,2)(1,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  9) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 9) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 9) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 9) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 0 2 1 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 0 2 1 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,1)(2,3)(0,4)
//******** Fan-out: 0=5; 1=2; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 10) cost 5 = (0,0)(0,0)(1,1)(2,3)(0,4)\n");
  fprintf(fid,"//*** 10) cost 5 = (0,0)(0,0)(1,1)(2,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  10) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 10) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 10) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 10) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 1 2 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 1 2 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,1)(2,3)(1,4)
//******** Fan-out: 0=4; 1=3; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 11) cost 5 = (0,0)(0,0)(1,1)(2,3)(1,4)\n");
  fprintf(fid,"//*** 11) cost 5 = (0,0)(0,0)(1,1)(2,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  11) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 11) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 11) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 11) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 1 2 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 1 2 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,2)(0,1)(3,4)
//******** Fan-out: 0=5; 1=2; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 12) cost 5 = (0,0)(0,0)(1,2)(0,1)(3,4)\n");
  fprintf(fid,"//*** 12) cost 5 = (0,0)(0,0)(1,2)(0,1)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d;
    f4d += v7d * f1d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  12) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 12) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 12) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 12) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 2 0 1 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 2 0 1 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,2)(0,3)(1,4)
//******** Fan-out: 0=5; 1=2; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 13) cost 5 = (0,0)(0,0)(1,2)(0,3)(1,4)\n");
  fprintf(fid,"//*** 13) cost 5 = (0,0)(0,0)(1,2)(0,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  13) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 13) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 13) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 13) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 2 0 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 2 0 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,2)(0,3)(3,4)
//******** Fan-out: 0=5; 1=1; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 14) cost 5 = (0,0)(0,0)(1,2)(0,3)(3,4)\n");
  fprintf(fid,"//*** 14) cost 5 = (0,0)(0,0)(1,2)(0,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  { //*** no loop since fanout=1 for node=1
  { //*** no loop since fanout=1 for node=2
    f3d =  f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  14) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 14) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 14) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 14) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 2 0 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 2 0 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,2)(0,3)(4,4)
//******** Fan-out: 0=5; 1=1; 2=1; 3=1; 4=2; 5=0; 
  printf("//*** 15) cost 5 = (0,0)(0,0)(1,2)(0,3)(4,4)\n");
  fprintf(fid,"//*** 15) cost 5 = (0,0)(0,0)(1,2)(0,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  { //*** no loop since fanout=1 for node=1
  { //*** no loop since fanout=1 for node=2
    f3d =  f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  15) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 15) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 15) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 15) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 2 0 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 2 0 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,2)(1,1)(3,4)
//******** Fan-out: 0=4; 1=3; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 16) cost 5 = (0,0)(0,0)(1,2)(1,1)(3,4)\n");
  fprintf(fid,"//*** 16) cost 5 = (0,0)(0,0)(1,2)(1,1)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f1d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  16) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 16) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 16) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 16) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 2 1 1 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 2 1 1 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,2)(1,3)(0,4)
//******** Fan-out: 0=5; 1=2; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 17) cost 5 = (0,0)(0,0)(1,2)(1,3)(0,4)\n");
  fprintf(fid,"//*** 17) cost 5 = (0,0)(0,0)(1,2)(1,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  17) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 17) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 17) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 17) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 2 1 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 2 1 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,2)(1,3)(1,4)
//******** Fan-out: 0=4; 1=3; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 18) cost 5 = (0,0)(0,0)(1,2)(1,3)(1,4)\n");
  fprintf(fid,"//*** 18) cost 5 = (0,0)(0,0)(1,2)(1,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  18) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 18) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 18) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 18) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 2 1 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 2 1 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,2)(3,3)(0,4)
//******** Fan-out: 0=5; 1=1; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 19) cost 5 = (0,0)(0,0)(1,2)(3,3)(0,4)\n");
  fprintf(fid,"//*** 19) cost 5 = (0,0)(0,0)(1,2)(3,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  { //*** no loop since fanout=1 for node=1
  { //*** no loop since fanout=1 for node=2
    f3d =  f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  19) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 19) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 19) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 19) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 2 3 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 2 3 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,2)(3,3)(3,4)
//******** Fan-out: 0=4; 1=1; 2=1; 3=3; 4=1; 5=0; 
  printf("//*** 20) cost 5 = (0,0)(0,0)(1,2)(3,3)(3,4)\n");
  fprintf(fid,"//*** 20) cost 5 = (0,0)(0,0)(1,2)(3,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  { //*** no loop since fanout=1 for node=1
  { //*** no loop since fanout=1 for node=2
    f3d =  f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  20) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 20) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 20) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 20) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 2 3 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 2 3 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,0)(2,3)(2,4)
//******** Fan-out: 0=5; 1=1; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 21) cost 5 = (0,0)(0,1)(0,0)(2,3)(2,4)\n");
  fprintf(fid,"//*** 21) cost 5 = (0,0)(0,1)(0,0)(2,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4];
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  21) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 21) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 21) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 21) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 0 2 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 0 2 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,0)(3,3)(2,4)
//******** Fan-out: 0=5; 1=1; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 22) cost 5 = (0,0)(0,1)(0,0)(3,3)(2,4)\n");
  fprintf(fid,"//*** 22) cost 5 = (0,0)(0,1)(0,0)(3,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4];
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=4
    f5d =  f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  22) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 22) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 22) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 22) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 0 3 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 0 3 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,1)(1,2)(3,4)
//******** Fan-out: 0=4; 1=3; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 23) cost 5 = (0,0)(0,1)(0,1)(1,2)(3,4)\n");
  fprintf(fid,"//*** 23) cost 5 = (0,0)(0,1)(0,1)(1,2)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=2
    f4d = v6d * f1d;
    f4d += f2d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  23) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 23) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 23) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 23) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 1 1 2 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 1 1 2 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,1)(2,3)(0,4)
//******** Fan-out: 0=5; 1=2; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 24) cost 5 = (0,0)(0,1)(0,1)(2,3)(0,4)\n");
  fprintf(fid,"//*** 24) cost 5 = (0,0)(0,1)(0,1)(2,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  24) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 24) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 24) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 24) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 1 2 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 1 2 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,1)(2,3)(1,4)
//******** Fan-out: 0=4; 1=3; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 25) cost 5 = (0,0)(0,1)(0,1)(2,3)(1,4)\n");
  fprintf(fid,"//*** 25) cost 5 = (0,0)(0,1)(0,1)(2,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  25) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 25) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 25) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 25) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 1 2 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 1 2 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(0,1)(3,4)
//******** Fan-out: 0=5; 1=2; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 26) cost 5 = (0,0)(0,1)(0,2)(0,1)(3,4)\n");
  fprintf(fid,"//*** 26) cost 5 = (0,0)(0,1)(0,2)(0,1)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d;
    f4d += v7d * f1d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  26) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 26) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 26) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 26) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 0 1 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 0 1 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(0,2)(3,4)
//******** Fan-out: 0=5; 1=1; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 27) cost 5 = (0,0)(0,1)(0,2)(0,2)(3,4)\n");
  fprintf(fid,"//*** 27) cost 5 = (0,0)(0,1)(0,2)(0,2)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d;
    f4d += v7d * f2d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  27) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 27) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 27) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 27) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 0 2 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 0 2 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(0,3)(1,4)
//******** Fan-out: 0=5; 1=2; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 28) cost 5 = (0,0)(0,1)(0,2)(0,3)(1,4)\n");
  fprintf(fid,"//*** 28) cost 5 = (0,0)(0,1)(0,2)(0,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  28) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 28) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 28) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 28) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 0 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 0 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(0,3)(2,4)
//******** Fan-out: 0=5; 1=1; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 29) cost 5 = (0,0)(0,1)(0,2)(0,3)(2,4)\n");
  fprintf(fid,"//*** 29) cost 5 = (0,0)(0,1)(0,2)(0,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  29) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 29) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 29) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 29) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 0 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 0 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(0,3)(3,4)
//******** Fan-out: 0=5; 1=1; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 30) cost 5 = (0,0)(0,1)(0,2)(0,3)(3,4)\n");
  fprintf(fid,"//*** 30) cost 5 = (0,0)(0,1)(0,2)(0,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  30) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 30) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 30) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 30) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 0 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 0 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(0,3)(4,4)
//******** Fan-out: 0=5; 1=1; 2=1; 3=1; 4=2; 5=0; 
  printf("//*** 31) cost 5 = (0,0)(0,1)(0,2)(0,3)(4,4)\n");
  fprintf(fid,"//*** 31) cost 5 = (0,0)(0,1)(0,2)(0,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  31) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 31) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 31) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 31) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 0 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 0 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(1,1)(3,4)
//******** Fan-out: 0=4; 1=3; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 32) cost 5 = (0,0)(0,1)(0,2)(1,1)(3,4)\n");
  fprintf(fid,"//*** 32) cost 5 = (0,0)(0,1)(0,2)(1,1)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f1d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  32) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 32) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 32) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 32) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 1 1 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 1 1 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(1,3)(0,4)
//******** Fan-out: 0=5; 1=2; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 33) cost 5 = (0,0)(0,1)(0,2)(1,3)(0,4)\n");
  fprintf(fid,"//*** 33) cost 5 = (0,0)(0,1)(0,2)(1,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  33) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 33) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 33) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 33) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 1 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 1 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(1,3)(1,4)
//******** Fan-out: 0=4; 1=3; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 34) cost 5 = (0,0)(0,1)(0,2)(1,3)(1,4)\n");
  fprintf(fid,"//*** 34) cost 5 = (0,0)(0,1)(0,2)(1,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  34) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 34) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 34) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 34) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 1 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 1 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(2,2)(3,4)
//******** Fan-out: 0=4; 1=1; 2=3; 3=1; 4=1; 5=0; 
  printf("//*** 35) cost 5 = (0,0)(0,1)(0,2)(2,2)(3,4)\n");
  fprintf(fid,"//*** 35) cost 5 = (0,0)(0,1)(0,2)(2,2)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f2d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  35) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 35) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 35) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 35) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 2 2 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 2 2 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(2,3)(0,4)
//******** Fan-out: 0=5; 1=1; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 36) cost 5 = (0,0)(0,1)(0,2)(2,3)(0,4)\n");
  fprintf(fid,"//*** 36) cost 5 = (0,0)(0,1)(0,2)(2,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  36) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 36) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 36) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 36) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 2 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 2 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(2,3)(2,4)
//******** Fan-out: 0=4; 1=1; 2=3; 3=1; 4=1; 5=0; 
  printf("//*** 37) cost 5 = (0,0)(0,1)(0,2)(2,3)(2,4)\n");
  fprintf(fid,"//*** 37) cost 5 = (0,0)(0,1)(0,2)(2,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  37) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 37) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 37) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 37) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 2 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 2 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(3,3)(0,4)
//******** Fan-out: 0=5; 1=1; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 38) cost 5 = (0,0)(0,1)(0,2)(3,3)(0,4)\n");
  fprintf(fid,"//*** 38) cost 5 = (0,0)(0,1)(0,2)(3,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  38) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 38) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 38) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 38) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 3 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 3 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(3,3)(3,4)
//******** Fan-out: 0=4; 1=1; 2=1; 3=3; 4=1; 5=0; 
  printf("//*** 39) cost 5 = (0,0)(0,1)(0,2)(3,3)(3,4)\n");
  fprintf(fid,"//*** 39) cost 5 = (0,0)(0,1)(0,2)(3,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  39) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 39) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 39) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 39) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 3 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 3 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,1)(1,2)(3,4)
//******** Fan-out: 0=3; 1=4; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 40) cost 5 = (0,0)(0,1)(1,1)(1,2)(3,4)\n");
  fprintf(fid,"//*** 40) cost 5 = (0,0)(0,1)(1,1)(1,2)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=2
    f4d = v6d * f1d;
    f4d += f2d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  40) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 40) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 40) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 40) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 1 1 2 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 1 1 2 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,1)(1,3)(2,4)
//******** Fan-out: 0=3; 1=4; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 41) cost 5 = (0,0)(0,1)(1,1)(1,3)(2,4)\n");
  fprintf(fid,"//*** 41) cost 5 = (0,0)(0,1)(1,1)(1,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=4
    f5d =  f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  41) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 41) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 41) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 41) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 1 1 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 1 1 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,1)(2,3)(0,4)
//******** Fan-out: 0=4; 1=3; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 42) cost 5 = (0,0)(0,1)(1,1)(2,3)(0,4)\n");
  fprintf(fid,"//*** 42) cost 5 = (0,0)(0,1)(1,1)(2,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  42) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 42) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 42) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 42) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 1 2 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 1 2 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,1)(2,3)(1,4)
//******** Fan-out: 0=3; 1=4; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 43) cost 5 = (0,0)(0,1)(1,1)(2,3)(1,4)\n");
  fprintf(fid,"//*** 43) cost 5 = (0,0)(0,1)(1,1)(2,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  43) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 43) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 43) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 43) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 1 2 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 1 2 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(0,0)(3,4)
//******** Fan-out: 0=5; 1=2; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 44) cost 5 = (0,0)(0,1)(1,2)(0,0)(3,4)\n");
  fprintf(fid,"//*** 44) cost 5 = (0,0)(0,1)(1,2)(0,0)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6];
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  44) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 44) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 44) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 44) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 0 0 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 0 0 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(0,3)(0,4)
//******** Fan-out: 0=5; 1=2; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 45) cost 5 = (0,0)(0,1)(1,2)(0,3)(0,4)\n");
  fprintf(fid,"//*** 45) cost 5 = (0,0)(0,1)(1,2)(0,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  45) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 45) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 45) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 45) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 0 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 0 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(0,3)(1,4)
//******** Fan-out: 0=4; 1=3; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 46) cost 5 = (0,0)(0,1)(1,2)(0,3)(1,4)\n");
  fprintf(fid,"//*** 46) cost 5 = (0,0)(0,1)(1,2)(0,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  46) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 46) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 46) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 46) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 0 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 0 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(1,3)(0,4)
//******** Fan-out: 0=4; 1=3; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 47) cost 5 = (0,0)(0,1)(1,2)(1,3)(0,4)\n");
  fprintf(fid,"//*** 47) cost 5 = (0,0)(0,1)(1,2)(1,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  47) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 47) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 47) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 47) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 1 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 1 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(1,3)(1,4)
//******** Fan-out: 0=3; 1=4; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 48) cost 5 = (0,0)(0,1)(1,2)(1,3)(1,4)\n");
  fprintf(fid,"//*** 48) cost 5 = (0,0)(0,1)(1,2)(1,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  48) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 48) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 48) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 48) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 1 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 1 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(0,0)(3,4)
//******** Fan-out: 0=5; 1=1; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 49) cost 5 = (0,0)(0,1)(2,2)(0,0)(3,4)\n");
  fprintf(fid,"//*** 49) cost 5 = (0,0)(0,1)(2,2)(0,0)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6];
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  49) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 49) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 49) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 49) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 0 0 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 0 0 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(0,3)(0,4)
//******** Fan-out: 0=5; 1=1; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 50) cost 5 = (0,0)(0,1)(2,2)(0,3)(0,4)\n");
  fprintf(fid,"//*** 50) cost 5 = (0,0)(0,1)(2,2)(0,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  50) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 50) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 50) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 50) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 0 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 0 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(0,3)(2,4)
//******** Fan-out: 0=4; 1=1; 2=3; 3=1; 4=1; 5=0; 
  printf("//*** 51) cost 5 = (0,0)(0,1)(2,2)(0,3)(2,4)\n");
  fprintf(fid,"//*** 51) cost 5 = (0,0)(0,1)(2,2)(0,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  51) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 51) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 51) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 51) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 0 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 0 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(2,2)(3,4)
//******** Fan-out: 0=3; 1=1; 2=4; 3=1; 4=1; 5=0; 
  printf("//*** 52) cost 5 = (0,0)(0,1)(2,2)(2,2)(3,4)\n");
  fprintf(fid,"//*** 52) cost 5 = (0,0)(0,1)(2,2)(2,2)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f2d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  52) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 52) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 52) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 52) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 2 2 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 2 2 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(2,3)(0,4)
//******** Fan-out: 0=4; 1=1; 2=3; 3=1; 4=1; 5=0; 
  printf("//*** 53) cost 5 = (0,0)(0,1)(2,2)(2,3)(0,4)\n");
  fprintf(fid,"//*** 53) cost 5 = (0,0)(0,1)(2,2)(2,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  53) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 53) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 53) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 53) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 2 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 2 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(2,3)(2,4)
//******** Fan-out: 0=3; 1=1; 2=4; 3=1; 4=1; 5=0; 
  printf("//*** 54) cost 5 = (0,0)(0,1)(2,2)(2,3)(2,4)\n");
  fprintf(fid,"//*** 54) cost 5 = (0,0)(0,1)(2,2)(2,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  54) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 54) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 54) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 54) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 2 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 2 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(0,0)(3,4)
//******** Fan-out: 0=5; 1=2; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 55) cost 5 = (0,0)(1,1)(0,2)(0,0)(3,4)\n");
  fprintf(fid,"//*** 55) cost 5 = (0,0)(1,1)(0,2)(0,0)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6];
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  55) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 55) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 55) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 55) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 0 0 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 0 0 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(0,1)(3,4)
//******** Fan-out: 0=4; 1=3; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 56) cost 5 = (0,0)(1,1)(0,2)(0,1)(3,4)\n");
  fprintf(fid,"//*** 56) cost 5 = (0,0)(1,1)(0,2)(0,1)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d;
    f4d += v7d * f1d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  56) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 56) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 56) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 56) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 0 1 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 0 1 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(0,3)(0,4)
//******** Fan-out: 0=5; 1=2; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 57) cost 5 = (0,0)(1,1)(0,2)(0,3)(0,4)\n");
  fprintf(fid,"//*** 57) cost 5 = (0,0)(1,1)(0,2)(0,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  57) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 57) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 57) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 57) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 0 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 0 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(0,3)(1,4)
//******** Fan-out: 0=4; 1=3; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 58) cost 5 = (0,0)(1,1)(0,2)(0,3)(1,4)\n");
  fprintf(fid,"//*** 58) cost 5 = (0,0)(1,1)(0,2)(0,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  58) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 58) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 58) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 58) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 0 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 0 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(1,1)(3,4)
//******** Fan-out: 0=3; 1=4; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 59) cost 5 = (0,0)(1,1)(0,2)(1,1)(3,4)\n");
  fprintf(fid,"//*** 59) cost 5 = (0,0)(1,1)(0,2)(1,1)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f1d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  59) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 59) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 59) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 59) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 1 1 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 1 1 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(1,3)(0,4)
//******** Fan-out: 0=4; 1=3; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 60) cost 5 = (0,0)(1,1)(0,2)(1,3)(0,4)\n");
  fprintf(fid,"//*** 60) cost 5 = (0,0)(1,1)(0,2)(1,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  60) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 60) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 60) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 60) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 1 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 1 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(1,3)(1,4)
//******** Fan-out: 0=3; 1=4; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 61) cost 5 = (0,0)(1,1)(0,2)(1,3)(1,4)\n");
  fprintf(fid,"//*** 61) cost 5 = (0,0)(1,1)(0,2)(1,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  61) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 61) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 61) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 61) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 1 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 1 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,1)(1,2)(3,4)
//******** Fan-out: 0=2; 1=5; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 62) cost 5 = (0,0)(1,1)(1,1)(1,2)(3,4)\n");
  fprintf(fid,"//*** 62) cost 5 = (0,0)(1,1)(1,1)(1,2)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=2
    f4d = v6d * f1d;
    f4d += f2d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  62) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 62) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 62) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 62) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 1 1 2 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 1 1 2 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,1)(2,3)(0,4)
//******** Fan-out: 0=3; 1=4; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 63) cost 5 = (0,0)(1,1)(1,1)(2,3)(0,4)\n");
  fprintf(fid,"//*** 63) cost 5 = (0,0)(1,1)(1,1)(2,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  63) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 63) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 63) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 63) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 1 2 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 1 2 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,1)(2,3)(1,4)
//******** Fan-out: 0=2; 1=5; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 64) cost 5 = (0,0)(1,1)(1,1)(2,3)(1,4)\n");
  fprintf(fid,"//*** 64) cost 5 = (0,0)(1,1)(1,1)(2,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  64) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 64) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 64) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 64) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 1 2 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 1 2 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(0,0)(3,4)
//******** Fan-out: 0=4; 1=3; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 65) cost 5 = (0,0)(1,1)(1,2)(0,0)(3,4)\n");
  fprintf(fid,"//*** 65) cost 5 = (0,0)(1,1)(1,2)(0,0)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6];
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  65) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 65) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 65) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 65) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 0 0 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 0 0 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(0,3)(0,4)
//******** Fan-out: 0=4; 1=3; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 66) cost 5 = (0,0)(1,1)(1,2)(0,3)(0,4)\n");
  fprintf(fid,"//*** 66) cost 5 = (0,0)(1,1)(1,2)(0,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  66) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 66) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 66) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 66) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 0 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 0 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(0,3)(1,4)
//******** Fan-out: 0=3; 1=4; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 67) cost 5 = (0,0)(1,1)(1,2)(0,3)(1,4)\n");
  fprintf(fid,"//*** 67) cost 5 = (0,0)(1,1)(1,2)(0,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  67) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 67) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 67) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 67) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 0 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 0 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(1,3)(0,4)
//******** Fan-out: 0=3; 1=4; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 68) cost 5 = (0,0)(1,1)(1,2)(1,3)(0,4)\n");
  fprintf(fid,"//*** 68) cost 5 = (0,0)(1,1)(1,2)(1,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  68) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 68) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 68) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 68) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 1 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 1 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(1,3)(1,4)
//******** Fan-out: 0=2; 1=5; 2=1; 3=1; 4=1; 5=0; 
  printf("//*** 69) cost 5 = (0,0)(1,1)(1,2)(1,3)(1,4)\n");
  fprintf(fid,"//*** 69) cost 5 = (0,0)(1,1)(1,2)(1,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  69) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 69) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 69) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 69) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 1 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 1 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,1)(2,3)(4,4)
//******** Fan-out: 0=4; 1=2; 2=1; 3=1; 4=2; 5=0; 
  printf("//*** 70) cost 5 = (0,0)(0,0)(1,1)(2,3)(4,4)\n");
  fprintf(fid,"//*** 70) cost 5 = (0,0)(0,0)(1,1)(2,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  70) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 70) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 70) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 70) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 1 2 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 1 2 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,2)(1,2)(3,4)
//******** Fan-out: 0=4; 1=2; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 71) cost 5 = (0,0)(0,0)(1,2)(1,2)(3,4)\n");
  fprintf(fid,"//*** 71) cost 5 = (0,0)(0,0)(1,2)(1,2)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d * f1d;
    f4d += v7d * f2d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  71) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 71) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 71) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 71) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 2 1 2 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 2 1 2 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,2)(1,3)(2,4)
//******** Fan-out: 0=4; 1=2; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 72) cost 5 = (0,0)(0,0)(1,2)(1,3)(2,4)\n");
  fprintf(fid,"//*** 72) cost 5 = (0,0)(0,0)(1,2)(1,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  72) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 72) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 72) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 72) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 2 1 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 2 1 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,2)(1,3)(3,4)
//******** Fan-out: 0=4; 1=2; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 73) cost 5 = (0,0)(0,0)(1,2)(1,3)(3,4)\n");
  fprintf(fid,"//*** 73) cost 5 = (0,0)(0,0)(1,2)(1,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d * f1d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  73) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 73) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 73) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 73) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 2 1 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 2 1 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,2)(1,3)(4,4)
//******** Fan-out: 0=4; 1=2; 2=1; 3=1; 4=2; 5=0; 
  printf("//*** 74) cost 5 = (0,0)(0,0)(1,2)(1,3)(4,4)\n");
  fprintf(fid,"//*** 74) cost 5 = (0,0)(0,0)(1,2)(1,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  74) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 74) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 74) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 74) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 2 1 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 2 1 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,2)(3,3)(1,4)
//******** Fan-out: 0=4; 1=2; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 75) cost 5 = (0,0)(0,0)(1,2)(3,3)(1,4)\n");
  fprintf(fid,"//*** 75) cost 5 = (0,0)(0,0)(1,2)(3,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  75) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 75) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 75) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 75) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 2 3 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 2 3 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(1,2)(3,3)(4,4)
//******** Fan-out: 0=4; 1=1; 2=1; 3=2; 4=2; 5=0; 
  printf("//*** 76) cost 5 = (0,0)(0,0)(1,2)(3,3)(4,4)\n");
  fprintf(fid,"//*** 76) cost 5 = (0,0)(0,0)(1,2)(3,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  { //*** no loop since fanout=1 for node=1
  { //*** no loop since fanout=1 for node=2
    f3d =  f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= slone; k6++) {{
    f4d = scone[k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  76) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 76) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 76) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 76) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 1 2 3 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 1 2 3 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,0)(2,2)(1,3)(1,4)
//******** Fan-out: 0=4; 1=2; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 77) cost 5 = (0,0)(0,0)(2,2)(1,3)(1,4)\n");
  fprintf(fid,"//*** 77) cost 5 = (0,0)(0,0)(2,2)(1,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2];
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  77) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 77) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 77) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 77) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 0 2 2 1 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 0 2 2 1 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,1)(2,2)(3,4)
//******** Fan-out: 0=4; 1=2; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 78) cost 5 = (0,0)(0,1)(0,1)(2,2)(3,4)\n");
  fprintf(fid,"//*** 78) cost 5 = (0,0)(0,1)(0,1)(2,2)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f2d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  78) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 78) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 78) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 78) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 1 2 2 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 1 2 2 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,1)(2,3)(2,4)
//******** Fan-out: 0=4; 1=2; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 79) cost 5 = (0,0)(0,1)(0,1)(2,3)(2,4)\n");
  fprintf(fid,"//*** 79) cost 5 = (0,0)(0,1)(0,1)(2,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  79) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 79) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 79) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 79) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 1 2 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 1 2 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,1)(2,3)(4,4)
//******** Fan-out: 0=4; 1=2; 2=1; 3=1; 4=2; 5=0; 
  printf("//*** 80) cost 5 = (0,0)(0,1)(0,1)(2,3)(4,4)\n");
  fprintf(fid,"//*** 80) cost 5 = (0,0)(0,1)(0,1)(2,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  80) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 80) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 80) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 80) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 1 2 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 1 2 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(1,2)(3,4)
//******** Fan-out: 0=4; 1=2; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 81) cost 5 = (0,0)(0,1)(0,2)(1,2)(3,4)\n");
  fprintf(fid,"//*** 81) cost 5 = (0,0)(0,1)(0,2)(1,2)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d * f1d;
    f4d += v7d * f2d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  81) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 81) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 81) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 81) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 1 2 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 1 2 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(1,3)(2,4)
//******** Fan-out: 0=4; 1=2; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 82) cost 5 = (0,0)(0,1)(0,2)(1,3)(2,4)\n");
  fprintf(fid,"//*** 82) cost 5 = (0,0)(0,1)(0,2)(1,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  82) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 82) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 82) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 82) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 1 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 1 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(1,3)(3,4)
//******** Fan-out: 0=4; 1=2; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 83) cost 5 = (0,0)(0,1)(0,2)(1,3)(3,4)\n");
  fprintf(fid,"//*** 83) cost 5 = (0,0)(0,1)(0,2)(1,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d * f1d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  83) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 83) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 83) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 83) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 1 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 1 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(1,3)(4,4)
//******** Fan-out: 0=4; 1=2; 2=1; 3=1; 4=2; 5=0; 
  printf("//*** 84) cost 5 = (0,0)(0,1)(0,2)(1,3)(4,4)\n");
  fprintf(fid,"//*** 84) cost 5 = (0,0)(0,1)(0,2)(1,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  84) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 84) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 84) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 84) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 1 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 1 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(2,3)(1,4)
//******** Fan-out: 0=4; 1=2; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 85) cost 5 = (0,0)(0,1)(0,2)(2,3)(1,4)\n");
  fprintf(fid,"//*** 85) cost 5 = (0,0)(0,1)(0,2)(2,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  85) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 85) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 85) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 85) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 2 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 2 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(2,3)(3,4)
//******** Fan-out: 0=4; 1=1; 2=2; 3=2; 4=1; 5=0; 
  printf("//*** 86) cost 5 = (0,0)(0,1)(0,2)(2,3)(3,4)\n");
  fprintf(fid,"//*** 86) cost 5 = (0,0)(0,1)(0,2)(2,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d * f2d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  86) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 86) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 86) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 86) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 2 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 2 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(2,3)(4,4)
//******** Fan-out: 0=4; 1=1; 2=2; 3=1; 4=2; 5=0; 
  printf("//*** 87) cost 5 = (0,0)(0,1)(0,2)(2,3)(4,4)\n");
  fprintf(fid,"//*** 87) cost 5 = (0,0)(0,1)(0,2)(2,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  87) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 87) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 87) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 87) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 2 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 2 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(3,3)(1,4)
//******** Fan-out: 0=4; 1=2; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 88) cost 5 = (0,0)(0,1)(0,2)(3,3)(1,4)\n");
  fprintf(fid,"//*** 88) cost 5 = (0,0)(0,1)(0,2)(3,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  88) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 88) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 88) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 88) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 3 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 3 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(3,3)(2,4)
//******** Fan-out: 0=4; 1=1; 2=2; 3=2; 4=1; 5=0; 
  printf("//*** 89) cost 5 = (0,0)(0,1)(0,2)(3,3)(2,4)\n");
  fprintf(fid,"//*** 89) cost 5 = (0,0)(0,1)(0,2)(3,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  89) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 89) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 89) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 89) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 3 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 3 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(0,2)(3,3)(4,4)
//******** Fan-out: 0=4; 1=1; 2=1; 3=2; 4=2; 5=0; 
  printf("//*** 90) cost 5 = (0,0)(0,1)(0,2)(3,3)(4,4)\n");
  fprintf(fid,"//*** 90) cost 5 = (0,0)(0,1)(0,2)(3,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= slone; k6++) {{
    f4d = scone[k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  90) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 90) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 90) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 90) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 0 2 3 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 0 2 3 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,1)(2,3)(2,4)
//******** Fan-out: 0=3; 1=3; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 91) cost 5 = (0,0)(0,1)(1,1)(2,3)(2,4)\n");
  fprintf(fid,"//*** 91) cost 5 = (0,0)(0,1)(1,1)(2,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  91) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 91) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 91) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 91) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 1 2 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 1 2 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,1)(2,3)(3,4)
//******** Fan-out: 0=3; 1=3; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 92) cost 5 = (0,0)(0,1)(1,1)(2,3)(3,4)\n");
  fprintf(fid,"//*** 92) cost 5 = (0,0)(0,1)(1,1)(2,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d =  f2d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  92) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 92) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 92) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 92) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 1 2 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 1 2 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,1)(2,3)(4,4)
//******** Fan-out: 0=3; 1=3; 2=1; 3=1; 4=2; 5=0; 
  printf("//*** 93) cost 5 = (0,0)(0,1)(1,1)(2,3)(4,4)\n");
  fprintf(fid,"//*** 93) cost 5 = (0,0)(0,1)(1,1)(2,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  93) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 93) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 93) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 93) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 1 2 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 1 2 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,1)(3,3)(2,4)
//******** Fan-out: 0=3; 1=3; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 94) cost 5 = (0,0)(0,1)(1,1)(3,3)(2,4)\n");
  fprintf(fid,"//*** 94) cost 5 = (0,0)(0,1)(1,1)(3,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=4
    f5d =  f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  94) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 94) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 94) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 94) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 1 3 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 1 3 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(0,3)(2,4)
//******** Fan-out: 0=4; 1=2; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 95) cost 5 = (0,0)(0,1)(1,2)(0,3)(2,4)\n");
  fprintf(fid,"//*** 95) cost 5 = (0,0)(0,1)(1,2)(0,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  95) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 95) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 95) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 95) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 0 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 0 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(0,3)(3,4)
//******** Fan-out: 0=4; 1=2; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 96) cost 5 = (0,0)(0,1)(1,2)(0,3)(3,4)\n");
  fprintf(fid,"//*** 96) cost 5 = (0,0)(0,1)(1,2)(0,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  96) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 96) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 96) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 96) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 0 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 0 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(0,3)(4,4)
//******** Fan-out: 0=4; 1=2; 2=1; 3=1; 4=2; 5=0; 
  printf("//*** 97) cost 5 = (0,0)(0,1)(1,2)(0,3)(4,4)\n");
  fprintf(fid,"//*** 97) cost 5 = (0,0)(0,1)(1,2)(0,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  97) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 97) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 97) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 97) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 0 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 0 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(1,2)(3,4)
//******** Fan-out: 0=3; 1=3; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 98) cost 5 = (0,0)(0,1)(1,2)(1,2)(3,4)\n");
  fprintf(fid,"//*** 98) cost 5 = (0,0)(0,1)(1,2)(1,2)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d * f1d;
    f4d += v7d * f2d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  98) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 98) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 98) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 98) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 1 2 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 1 2 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(1,3)(2,4)
//******** Fan-out: 0=3; 1=3; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 99) cost 5 = (0,0)(0,1)(1,2)(1,3)(2,4)\n");
  fprintf(fid,"//*** 99) cost 5 = (0,0)(0,1)(1,2)(1,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  99) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 99) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 99) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 99) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 1 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 1 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(1,3)(3,4)
//******** Fan-out: 0=3; 1=3; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 100) cost 5 = (0,0)(0,1)(1,2)(1,3)(3,4)\n");
  fprintf(fid,"//*** 100) cost 5 = (0,0)(0,1)(1,2)(1,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d * f1d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  100) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 100) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 100) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 100) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 1 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 1 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(1,3)(4,4)
//******** Fan-out: 0=3; 1=3; 2=1; 3=1; 4=2; 5=0; 
  printf("//*** 101) cost 5 = (0,0)(0,1)(1,2)(1,3)(4,4)\n");
  fprintf(fid,"//*** 101) cost 5 = (0,0)(0,1)(1,2)(1,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  101) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 101) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 101) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 101) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 1 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 1 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(2,2)(3,4)
//******** Fan-out: 0=3; 1=2; 2=3; 3=1; 4=1; 5=0; 
  printf("//*** 102) cost 5 = (0,0)(0,1)(1,2)(2,2)(3,4)\n");
  fprintf(fid,"//*** 102) cost 5 = (0,0)(0,1)(1,2)(2,2)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f2d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  102) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 102) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 102) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 102) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 2 2 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 2 2 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(2,3)(0,4)
//******** Fan-out: 0=4; 1=2; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 103) cost 5 = (0,0)(0,1)(1,2)(2,3)(0,4)\n");
  fprintf(fid,"//*** 103) cost 5 = (0,0)(0,1)(1,2)(2,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  103) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 103) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 103) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 103) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 2 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 2 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(2,3)(1,4)
//******** Fan-out: 0=3; 1=3; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 104) cost 5 = (0,0)(0,1)(1,2)(2,3)(1,4)\n");
  fprintf(fid,"//*** 104) cost 5 = (0,0)(0,1)(1,2)(2,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  104) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 104) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 104) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 104) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 2 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 2 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(2,3)(2,4)
//******** Fan-out: 0=3; 1=2; 2=3; 3=1; 4=1; 5=0; 
  printf("//*** 105) cost 5 = (0,0)(0,1)(1,2)(2,3)(2,4)\n");
  fprintf(fid,"//*** 105) cost 5 = (0,0)(0,1)(1,2)(2,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  105) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 105) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 105) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 105) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 2 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 2 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(3,3)(0,4)
//******** Fan-out: 0=4; 1=2; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 106) cost 5 = (0,0)(0,1)(1,2)(3,3)(0,4)\n");
  fprintf(fid,"//*** 106) cost 5 = (0,0)(0,1)(1,2)(3,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  106) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 106) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 106) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 106) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 3 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 3 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(3,3)(1,4)
//******** Fan-out: 0=3; 1=3; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 107) cost 5 = (0,0)(0,1)(1,2)(3,3)(1,4)\n");
  fprintf(fid,"//*** 107) cost 5 = (0,0)(0,1)(1,2)(3,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  107) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 107) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 107) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 107) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 3 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 3 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(3,3)(3,4)
//******** Fan-out: 0=3; 1=2; 2=1; 3=3; 4=1; 5=0; 
  printf("//*** 108) cost 5 = (0,0)(0,1)(1,2)(3,3)(3,4)\n");
  fprintf(fid,"//*** 108) cost 5 = (0,0)(0,1)(1,2)(3,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  108) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 108) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 108) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 108) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 3 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 3 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(0,3)(1,4)
//******** Fan-out: 0=4; 1=2; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 109) cost 5 = (0,0)(0,1)(2,2)(0,3)(1,4)\n");
  fprintf(fid,"//*** 109) cost 5 = (0,0)(0,1)(2,2)(0,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  109) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 109) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 109) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 109) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 0 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 0 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(0,3)(3,4)
//******** Fan-out: 0=4; 1=1; 2=2; 3=2; 4=1; 5=0; 
  printf("//*** 110) cost 5 = (0,0)(0,1)(2,2)(0,3)(3,4)\n");
  fprintf(fid,"//*** 110) cost 5 = (0,0)(0,1)(2,2)(0,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  110) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 110) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 110) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 110) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 0 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 0 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(0,3)(4,4)
//******** Fan-out: 0=4; 1=1; 2=2; 3=1; 4=2; 5=0; 
  printf("//*** 111) cost 5 = (0,0)(0,1)(2,2)(0,3)(4,4)\n");
  fprintf(fid,"//*** 111) cost 5 = (0,0)(0,1)(2,2)(0,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  111) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 111) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 111) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 111) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 0 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 0 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(1,1)(3,4)
//******** Fan-out: 0=3; 1=3; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 112) cost 5 = (0,0)(0,1)(2,2)(1,1)(3,4)\n");
  fprintf(fid,"//*** 112) cost 5 = (0,0)(0,1)(2,2)(1,1)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f1d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  112) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 112) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 112) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 112) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 1 1 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 1 1 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(1,3)(0,4)
//******** Fan-out: 0=4; 1=2; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 113) cost 5 = (0,0)(0,1)(2,2)(1,3)(0,4)\n");
  fprintf(fid,"//*** 113) cost 5 = (0,0)(0,1)(2,2)(1,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  113) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 113) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 113) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 113) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 1 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 1 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(1,3)(1,4)
//******** Fan-out: 0=3; 1=3; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 114) cost 5 = (0,0)(0,1)(2,2)(1,3)(1,4)\n");
  fprintf(fid,"//*** 114) cost 5 = (0,0)(0,1)(2,2)(1,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  114) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 114) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 114) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 114) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 1 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 1 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(1,3)(2,4)
//******** Fan-out: 0=3; 1=2; 2=3; 3=1; 4=1; 5=0; 
  printf("//*** 115) cost 5 = (0,0)(0,1)(2,2)(1,3)(2,4)\n");
  fprintf(fid,"//*** 115) cost 5 = (0,0)(0,1)(2,2)(1,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  115) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 115) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 115) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 115) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 1 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 1 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(2,3)(1,4)
//******** Fan-out: 0=3; 1=2; 2=3; 3=1; 4=1; 5=0; 
  printf("//*** 116) cost 5 = (0,0)(0,1)(2,2)(2,3)(1,4)\n");
  fprintf(fid,"//*** 116) cost 5 = (0,0)(0,1)(2,2)(2,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  116) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 116) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 116) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 116) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 2 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 2 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(2,3)(3,4)
//******** Fan-out: 0=3; 1=1; 2=3; 3=2; 4=1; 5=0; 
  printf("//*** 117) cost 5 = (0,0)(0,1)(2,2)(2,3)(3,4)\n");
  fprintf(fid,"//*** 117) cost 5 = (0,0)(0,1)(2,2)(2,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d * f2d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  117) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 117) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 117) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 117) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 2 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 2 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(2,3)(4,4)
//******** Fan-out: 0=3; 1=1; 2=3; 3=1; 4=2; 5=0; 
  printf("//*** 118) cost 5 = (0,0)(0,1)(2,2)(2,3)(4,4)\n");
  fprintf(fid,"//*** 118) cost 5 = (0,0)(0,1)(2,2)(2,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  118) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 118) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 118) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 118) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 2 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 2 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(3,3)(0,4)
//******** Fan-out: 0=4; 1=1; 2=2; 3=2; 4=1; 5=0; 
  printf("//*** 119) cost 5 = (0,0)(0,1)(2,2)(3,3)(0,4)\n");
  fprintf(fid,"//*** 119) cost 5 = (0,0)(0,1)(2,2)(3,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  119) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 119) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 119) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 119) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 3 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 3 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(3,3)(2,4)
//******** Fan-out: 0=3; 1=1; 2=3; 3=2; 4=1; 5=0; 
  printf("//*** 120) cost 5 = (0,0)(0,1)(2,2)(3,3)(2,4)\n");
  fprintf(fid,"//*** 120) cost 5 = (0,0)(0,1)(2,2)(3,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  120) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 120) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 120) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 120) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 3 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 3 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(3,3)(3,4)
//******** Fan-out: 0=3; 1=1; 2=2; 3=3; 4=1; 5=0; 
  printf("//*** 121) cost 5 = (0,0)(0,1)(2,2)(3,3)(3,4)\n");
  fprintf(fid,"//*** 121) cost 5 = (0,0)(0,1)(2,2)(3,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  121) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 121) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 121) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 121) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 3 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 3 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,0)(2,3)(2,4)
//******** Fan-out: 0=4; 1=2; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 122) cost 5 = (0,0)(1,1)(0,0)(2,3)(2,4)\n");
  fprintf(fid,"//*** 122) cost 5 = (0,0)(1,1)(0,0)(2,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4];
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  122) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 122) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 122) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 122) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 0 2 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 0 2 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,0)(3,3)(2,4)
//******** Fan-out: 0=4; 1=2; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 123) cost 5 = (0,0)(1,1)(0,0)(3,3)(2,4)\n");
  fprintf(fid,"//*** 123) cost 5 = (0,0)(1,1)(0,0)(3,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4];
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=4
    f5d =  f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  123) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 123) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 123) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 123) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 0 3 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 0 3 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(0,2)(3,4)
//******** Fan-out: 0=4; 1=2; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 124) cost 5 = (0,0)(1,1)(0,2)(0,2)(3,4)\n");
  fprintf(fid,"//*** 124) cost 5 = (0,0)(1,1)(0,2)(0,2)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d;
    f4d += v7d * f2d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  124) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 124) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 124) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 124) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 0 2 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 0 2 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(0,3)(2,4)
//******** Fan-out: 0=4; 1=2; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 125) cost 5 = (0,0)(1,1)(0,2)(0,3)(2,4)\n");
  fprintf(fid,"//*** 125) cost 5 = (0,0)(1,1)(0,2)(0,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  125) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 125) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 125) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 125) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 0 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 0 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(0,3)(3,4)
//******** Fan-out: 0=4; 1=2; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 126) cost 5 = (0,0)(1,1)(0,2)(0,3)(3,4)\n");
  fprintf(fid,"//*** 126) cost 5 = (0,0)(1,1)(0,2)(0,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  126) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 126) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 126) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 126) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 0 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 0 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(0,3)(4,4)
//******** Fan-out: 0=4; 1=2; 2=1; 3=1; 4=2; 5=0; 
  printf("//*** 127) cost 5 = (0,0)(1,1)(0,2)(0,3)(4,4)\n");
  fprintf(fid,"//*** 127) cost 5 = (0,0)(1,1)(0,2)(0,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  127) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 127) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 127) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 127) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 0 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 0 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(1,2)(3,4)
//******** Fan-out: 0=3; 1=3; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 128) cost 5 = (0,0)(1,1)(0,2)(1,2)(3,4)\n");
  fprintf(fid,"//*** 128) cost 5 = (0,0)(1,1)(0,2)(1,2)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d * f1d;
    f4d += v7d * f2d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  128) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 128) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 128) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 128) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 1 2 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 1 2 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(1,3)(2,4)
//******** Fan-out: 0=3; 1=3; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 129) cost 5 = (0,0)(1,1)(0,2)(1,3)(2,4)\n");
  fprintf(fid,"//*** 129) cost 5 = (0,0)(1,1)(0,2)(1,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  129) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 129) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 129) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 129) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 1 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 1 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(1,3)(3,4)
//******** Fan-out: 0=3; 1=3; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 130) cost 5 = (0,0)(1,1)(0,2)(1,3)(3,4)\n");
  fprintf(fid,"//*** 130) cost 5 = (0,0)(1,1)(0,2)(1,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d * f1d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  130) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 130) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 130) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 130) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 1 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 1 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(1,3)(4,4)
//******** Fan-out: 0=3; 1=3; 2=1; 3=1; 4=2; 5=0; 
  printf("//*** 131) cost 5 = (0,0)(1,1)(0,2)(1,3)(4,4)\n");
  fprintf(fid,"//*** 131) cost 5 = (0,0)(1,1)(0,2)(1,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  131) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 131) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 131) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 131) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 1 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 1 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(2,2)(3,4)
//******** Fan-out: 0=3; 1=2; 2=3; 3=1; 4=1; 5=0; 
  printf("//*** 132) cost 5 = (0,0)(1,1)(0,2)(2,2)(3,4)\n");
  fprintf(fid,"//*** 132) cost 5 = (0,0)(1,1)(0,2)(2,2)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f2d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  132) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 132) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 132) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 132) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 2 2 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 2 2 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(2,3)(0,4)
//******** Fan-out: 0=4; 1=2; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 133) cost 5 = (0,0)(1,1)(0,2)(2,3)(0,4)\n");
  fprintf(fid,"//*** 133) cost 5 = (0,0)(1,1)(0,2)(2,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  133) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 133) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 133) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 133) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 2 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 2 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(2,3)(1,4)
//******** Fan-out: 0=3; 1=3; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 134) cost 5 = (0,0)(1,1)(0,2)(2,3)(1,4)\n");
  fprintf(fid,"//*** 134) cost 5 = (0,0)(1,1)(0,2)(2,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  134) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 134) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 134) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 134) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 2 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 2 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(2,3)(2,4)
//******** Fan-out: 0=3; 1=2; 2=3; 3=1; 4=1; 5=0; 
  printf("//*** 135) cost 5 = (0,0)(1,1)(0,2)(2,3)(2,4)\n");
  fprintf(fid,"//*** 135) cost 5 = (0,0)(1,1)(0,2)(2,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  135) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 135) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 135) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 135) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 2 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 2 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(3,3)(0,4)
//******** Fan-out: 0=4; 1=2; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 136) cost 5 = (0,0)(1,1)(0,2)(3,3)(0,4)\n");
  fprintf(fid,"//*** 136) cost 5 = (0,0)(1,1)(0,2)(3,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  136) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 136) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 136) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 136) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 3 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 3 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(3,3)(1,4)
//******** Fan-out: 0=3; 1=3; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 137) cost 5 = (0,0)(1,1)(0,2)(3,3)(1,4)\n");
  fprintf(fid,"//*** 137) cost 5 = (0,0)(1,1)(0,2)(3,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  137) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 137) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 137) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 137) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 3 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 3 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(3,3)(3,4)
//******** Fan-out: 0=3; 1=2; 2=1; 3=3; 4=1; 5=0; 
  printf("//*** 138) cost 5 = (0,0)(1,1)(0,2)(3,3)(3,4)\n");
  fprintf(fid,"//*** 138) cost 5 = (0,0)(1,1)(0,2)(3,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  138) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 138) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 138) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 138) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 3 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 3 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,1)(2,2)(3,4)
//******** Fan-out: 0=2; 1=4; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 139) cost 5 = (0,0)(1,1)(1,1)(2,2)(3,4)\n");
  fprintf(fid,"//*** 139) cost 5 = (0,0)(1,1)(1,1)(2,2)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f2d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  139) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 139) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 139) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 139) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 1 2 2 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 1 2 2 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,1)(2,3)(2,4)
//******** Fan-out: 0=2; 1=4; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 140) cost 5 = (0,0)(1,1)(1,1)(2,3)(2,4)\n");
  fprintf(fid,"//*** 140) cost 5 = (0,0)(1,1)(1,1)(2,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  140) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 140) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 140) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 140) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 1 2 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 1 2 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,1)(2,3)(4,4)
//******** Fan-out: 0=2; 1=4; 2=1; 3=1; 4=2; 5=0; 
  printf("//*** 141) cost 5 = (0,0)(1,1)(1,1)(2,3)(4,4)\n");
  fprintf(fid,"//*** 141) cost 5 = (0,0)(1,1)(1,1)(2,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f1d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  { //*** no loop since fanout=1 for node=2
  { //*** no loop since fanout=1 for node=3
    f4d =  f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  141) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 141) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 141) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 141) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 1 2 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 1 2 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(0,3)(2,4)
//******** Fan-out: 0=3; 1=3; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 142) cost 5 = (0,0)(1,1)(1,2)(0,3)(2,4)\n");
  fprintf(fid,"//*** 142) cost 5 = (0,0)(1,1)(1,2)(0,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  142) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 142) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 142) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 142) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 0 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 0 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(0,3)(3,4)
//******** Fan-out: 0=3; 1=3; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 143) cost 5 = (0,0)(1,1)(1,2)(0,3)(3,4)\n");
  fprintf(fid,"//*** 143) cost 5 = (0,0)(1,1)(1,2)(0,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  143) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 143) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 143) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 143) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 0 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 0 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(0,3)(4,4)
//******** Fan-out: 0=3; 1=3; 2=1; 3=1; 4=2; 5=0; 
  printf("//*** 144) cost 5 = (0,0)(1,1)(1,2)(0,3)(4,4)\n");
  fprintf(fid,"//*** 144) cost 5 = (0,0)(1,1)(1,2)(0,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  144) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 144) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 144) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 144) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 0 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 0 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(1,2)(3,4)
//******** Fan-out: 0=2; 1=4; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 145) cost 5 = (0,0)(1,1)(1,2)(1,2)(3,4)\n");
  fprintf(fid,"//*** 145) cost 5 = (0,0)(1,1)(1,2)(1,2)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d * f1d;
    f4d += v7d * f2d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  145) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 145) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 145) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 145) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 1 2 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 1 2 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(1,3)(2,4)
//******** Fan-out: 0=2; 1=4; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 146) cost 5 = (0,0)(1,1)(1,2)(1,3)(2,4)\n");
  fprintf(fid,"//*** 146) cost 5 = (0,0)(1,1)(1,2)(1,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  146) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 146) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 146) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 146) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 1 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 1 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(1,3)(3,4)
//******** Fan-out: 0=2; 1=4; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 147) cost 5 = (0,0)(1,1)(1,2)(1,3)(3,4)\n");
  fprintf(fid,"//*** 147) cost 5 = (0,0)(1,1)(1,2)(1,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d * f1d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  147) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 147) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 147) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 147) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 1 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 1 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(1,3)(4,4)
//******** Fan-out: 0=2; 1=4; 2=1; 3=1; 4=2; 5=0; 
  printf("//*** 148) cost 5 = (0,0)(1,1)(1,2)(1,3)(4,4)\n");
  fprintf(fid,"//*** 148) cost 5 = (0,0)(1,1)(1,2)(1,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  148) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 148) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 148) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 148) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 1 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 1 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(2,2)(3,4)
//******** Fan-out: 0=2; 1=3; 2=3; 3=1; 4=1; 5=0; 
  printf("//*** 149) cost 5 = (0,0)(1,1)(1,2)(2,2)(3,4)\n");
  fprintf(fid,"//*** 149) cost 5 = (0,0)(1,1)(1,2)(2,2)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f2d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  149) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 149) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 149) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 149) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 2 2 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 2 2 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(2,3)(0,4)
//******** Fan-out: 0=3; 1=3; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 150) cost 5 = (0,0)(1,1)(1,2)(2,3)(0,4)\n");
  fprintf(fid,"//*** 150) cost 5 = (0,0)(1,1)(1,2)(2,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  150) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 150) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 150) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 150) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 2 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 2 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(2,3)(1,4)
//******** Fan-out: 0=2; 1=4; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 151) cost 5 = (0,0)(1,1)(1,2)(2,3)(1,4)\n");
  fprintf(fid,"//*** 151) cost 5 = (0,0)(1,1)(1,2)(2,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  151) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 151) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 151) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 151) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 2 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 2 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(2,3)(2,4)
//******** Fan-out: 0=2; 1=3; 2=3; 3=1; 4=1; 5=0; 
  printf("//*** 152) cost 5 = (0,0)(1,1)(1,2)(2,3)(2,4)\n");
  fprintf(fid,"//*** 152) cost 5 = (0,0)(1,1)(1,2)(2,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  152) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 152) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 152) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 152) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 2 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 2 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(3,3)(0,4)
//******** Fan-out: 0=3; 1=3; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 153) cost 5 = (0,0)(1,1)(1,2)(3,3)(0,4)\n");
  fprintf(fid,"//*** 153) cost 5 = (0,0)(1,1)(1,2)(3,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  153) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 153) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 153) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 153) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 3 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 3 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(3,3)(1,4)
//******** Fan-out: 0=2; 1=4; 2=1; 3=2; 4=1; 5=0; 
  printf("//*** 154) cost 5 = (0,0)(1,1)(1,2)(3,3)(1,4)\n");
  fprintf(fid,"//*** 154) cost 5 = (0,0)(1,1)(1,2)(3,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  154) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 154) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 154) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 154) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 3 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 3 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(3,3)(3,4)
//******** Fan-out: 0=2; 1=3; 2=1; 3=3; 4=1; 5=0; 
  printf("//*** 155) cost 5 = (0,0)(1,1)(1,2)(3,3)(3,4)\n");
  fprintf(fid,"//*** 155) cost 5 = (0,0)(1,1)(1,2)(3,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  155) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 155) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 155) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 155) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 3 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 3 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(0,0)(3,4)
//******** Fan-out: 0=4; 1=2; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 156) cost 5 = (0,0)(1,1)(2,2)(0,0)(3,4)\n");
  fprintf(fid,"//*** 156) cost 5 = (0,0)(1,1)(2,2)(0,0)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6];
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  156) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 156) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 156) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 156) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 0 0 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 0 0 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(0,3)(0,4)
//******** Fan-out: 0=4; 1=2; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 157) cost 5 = (0,0)(1,1)(2,2)(0,3)(0,4)\n");
  fprintf(fid,"//*** 157) cost 5 = (0,0)(1,1)(2,2)(0,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  157) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 157) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 157) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 157) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 0 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 0 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(0,3)(1,4)
//******** Fan-out: 0=3; 1=3; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 158) cost 5 = (0,0)(1,1)(2,2)(0,3)(1,4)\n");
  fprintf(fid,"//*** 158) cost 5 = (0,0)(1,1)(2,2)(0,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  158) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 158) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 158) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 158) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 0 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 0 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(0,3)(2,4)
//******** Fan-out: 0=3; 1=2; 2=3; 3=1; 4=1; 5=0; 
  printf("//*** 159) cost 5 = (0,0)(1,1)(2,2)(0,3)(2,4)\n");
  fprintf(fid,"//*** 159) cost 5 = (0,0)(1,1)(2,2)(0,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  159) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 159) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 159) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 159) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 0 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 0 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(1,3)(0,4)
//******** Fan-out: 0=3; 1=3; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 160) cost 5 = (0,0)(1,1)(2,2)(1,3)(0,4)\n");
  fprintf(fid,"//*** 160) cost 5 = (0,0)(1,1)(2,2)(1,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  160) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 160) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 160) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 160) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 1 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 1 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(1,3)(1,4)
//******** Fan-out: 0=2; 1=4; 2=2; 3=1; 4=1; 5=0; 
  printf("//*** 161) cost 5 = (0,0)(1,1)(2,2)(1,3)(1,4)\n");
  fprintf(fid,"//*** 161) cost 5 = (0,0)(1,1)(2,2)(1,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  161) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 161) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 161) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 161) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 1 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 1 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(1,3)(2,4)
//******** Fan-out: 0=2; 1=3; 2=3; 3=1; 4=1; 5=0; 
  printf("//*** 162) cost 5 = (0,0)(1,1)(2,2)(1,3)(2,4)\n");
  fprintf(fid,"//*** 162) cost 5 = (0,0)(1,1)(2,2)(1,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  162) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 162) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 162) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 162) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 1 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 1 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(2,2)(3,4)
//******** Fan-out: 0=2; 1=2; 2=4; 3=1; 4=1; 5=0; 
  printf("//*** 163) cost 5 = (0,0)(1,1)(2,2)(2,2)(3,4)\n");
  fprintf(fid,"//*** 163) cost 5 = (0,0)(1,1)(2,2)(2,2)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f2d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  { //*** no loop since fanout=1 for node=3
  { //*** no loop since fanout=1 for node=4
    f5d =  f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  163) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 163) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 163) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 163) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 2 2 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 2 2 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(2,3)(0,4)
//******** Fan-out: 0=3; 1=2; 2=3; 3=1; 4=1; 5=0; 
  printf("//*** 164) cost 5 = (0,0)(1,1)(2,2)(2,3)(0,4)\n");
  fprintf(fid,"//*** 164) cost 5 = (0,0)(1,1)(2,2)(2,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  164) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 164) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 164) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 164) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 2 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 2 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(2,3)(1,4)
//******** Fan-out: 0=2; 1=3; 2=3; 3=1; 4=1; 5=0; 
  printf("//*** 165) cost 5 = (0,0)(1,1)(2,2)(2,3)(1,4)\n");
  fprintf(fid,"//*** 165) cost 5 = (0,0)(1,1)(2,2)(2,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  165) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 165) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 165) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 165) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 2 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 2 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(2,3)(2,4)
//******** Fan-out: 0=2; 1=2; 2=4; 3=1; 4=1; 5=0; 
  printf("//*** 166) cost 5 = (0,0)(1,1)(2,2)(2,3)(2,4)\n");
  fprintf(fid,"//*** 166) cost 5 = (0,0)(1,1)(2,2)(2,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  166) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 166) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 166) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 166) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 2 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 2 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(2,3)(3,4)
//******** Fan-out: 0=3; 1=2; 2=2; 3=2; 4=1; 5=0; 
  printf("//*** 167) cost 5 = (0,0)(0,1)(1,2)(2,3)(3,4)\n");
  fprintf(fid,"//*** 167) cost 5 = (0,0)(0,1)(1,2)(2,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d * f2d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  167) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 167) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 167) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 167) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 2 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 2 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(2,3)(4,4)
//******** Fan-out: 0=3; 1=2; 2=2; 3=1; 4=2; 5=0; 
  printf("//*** 168) cost 5 = (0,0)(0,1)(1,2)(2,3)(4,4)\n");
  fprintf(fid,"//*** 168) cost 5 = (0,0)(0,1)(1,2)(2,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  168) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 168) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 168) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 168) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 2 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 2 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(3,3)(2,4)
//******** Fan-out: 0=3; 1=2; 2=2; 3=2; 4=1; 5=0; 
  printf("//*** 169) cost 5 = (0,0)(0,1)(1,2)(3,3)(2,4)\n");
  fprintf(fid,"//*** 169) cost 5 = (0,0)(0,1)(1,2)(3,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  169) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 169) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 169) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 169) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 3 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 3 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(1,2)(3,3)(4,4)
//******** Fan-out: 0=3; 1=2; 2=1; 3=2; 4=2; 5=0; 
  printf("//*** 170) cost 5 = (0,0)(0,1)(1,2)(3,3)(4,4)\n");
  fprintf(fid,"//*** 170) cost 5 = (0,0)(0,1)(1,2)(3,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= slone; k6++) {{
    f4d = scone[k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  170) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 170) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 170) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 170) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 1 2 3 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 1 2 3 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(1,3)(3,4)
//******** Fan-out: 0=3; 1=2; 2=2; 3=2; 4=1; 5=0; 
  printf("//*** 171) cost 5 = (0,0)(0,1)(2,2)(1,3)(3,4)\n");
  fprintf(fid,"//*** 171) cost 5 = (0,0)(0,1)(2,2)(1,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d * f1d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  171) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 171) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 171) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 171) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 1 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 1 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(1,3)(4,4)
//******** Fan-out: 0=3; 1=2; 2=2; 3=1; 4=2; 5=0; 
  printf("//*** 172) cost 5 = (0,0)(0,1)(2,2)(1,3)(4,4)\n");
  fprintf(fid,"//*** 172) cost 5 = (0,0)(0,1)(2,2)(1,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  172) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 172) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 172) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 172) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 1 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 1 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(3,3)(1,4)
//******** Fan-out: 0=3; 1=2; 2=2; 3=2; 4=1; 5=0; 
  printf("//*** 173) cost 5 = (0,0)(0,1)(2,2)(3,3)(1,4)\n");
  fprintf(fid,"//*** 173) cost 5 = (0,0)(0,1)(2,2)(3,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
   for (k3 = 1; k3 <= sl[0]; k3++) {
    v3d = sc[0][k3];
    f2d = v2d;
    f2d += v3d * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  173) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 173) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 173) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 173) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 3 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 3 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(0,1)(2,2)(3,3)(4,4)
//******** Fan-out: 0=3; 1=1; 2=2; 3=2; 4=2; 5=0; 
  printf("//*** 174) cost 5 = (0,0)(0,1)(2,2)(3,3)(4,4)\n");
  fprintf(fid,"//*** 174) cost 5 = (0,0)(0,1)(2,2)(3,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= sl[1]; k0++) {{
    f1d = sc[1][k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[0]; k2++) {
   v2d = sc[0][k2];
  { //*** no loop since fanout=1 for node=1
    f2d = v2d;
    f2d += f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= slone; k6++) {{
    f4d = scone[k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  174) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 174) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 174) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 174) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 0 1 2 2 3 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 0 1 2 2 3 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(2,3)(3,4)
//******** Fan-out: 0=3; 1=2; 2=2; 3=2; 4=1; 5=0; 
  printf("//*** 175) cost 5 = (0,0)(1,1)(0,2)(2,3)(3,4)\n");
  fprintf(fid,"//*** 175) cost 5 = (0,0)(1,1)(0,2)(2,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d * f2d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  175) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 175) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 175) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 175) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 2 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 2 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(2,3)(4,4)
//******** Fan-out: 0=3; 1=2; 2=2; 3=1; 4=2; 5=0; 
  printf("//*** 176) cost 5 = (0,0)(1,1)(0,2)(2,3)(4,4)\n");
  fprintf(fid,"//*** 176) cost 5 = (0,0)(1,1)(0,2)(2,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  176) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 176) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 176) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 176) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 2 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 2 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(3,3)(2,4)
//******** Fan-out: 0=3; 1=2; 2=2; 3=2; 4=1; 5=0; 
  printf("//*** 177) cost 5 = (0,0)(1,1)(0,2)(3,3)(2,4)\n");
  fprintf(fid,"//*** 177) cost 5 = (0,0)(1,1)(0,2)(3,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  177) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 177) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 177) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 177) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 3 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 3 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(0,2)(3,3)(4,4)
//******** Fan-out: 0=3; 1=2; 2=1; 3=2; 4=2; 5=0; 
  printf("//*** 178) cost 5 = (0,0)(1,1)(0,2)(3,3)(4,4)\n");
  fprintf(fid,"//*** 178) cost 5 = (0,0)(1,1)(0,2)(3,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= slone; k6++) {{
    f4d = scone[k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  178) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 178) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 178) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 178) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 0 2 3 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 0 2 3 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(2,3)(3,4)
//******** Fan-out: 0=2; 1=3; 2=2; 3=2; 4=1; 5=0; 
  printf("//*** 179) cost 5 = (0,0)(1,1)(1,2)(2,3)(3,4)\n");
  fprintf(fid,"//*** 179) cost 5 = (0,0)(1,1)(1,2)(2,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d * f2d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  179) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 179) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 179) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 179) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 2 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 2 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(2,3)(4,4)
//******** Fan-out: 0=2; 1=3; 2=2; 3=1; 4=2; 5=0; 
  printf("//*** 180) cost 5 = (0,0)(1,1)(1,2)(2,3)(4,4)\n");
  fprintf(fid,"//*** 180) cost 5 = (0,0)(1,1)(1,2)(2,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  180) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 180) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 180) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 180) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 2 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 2 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(3,3)(2,4)
//******** Fan-out: 0=2; 1=3; 2=2; 3=2; 4=1; 5=0; 
  printf("//*** 181) cost 5 = (0,0)(1,1)(1,2)(3,3)(2,4)\n");
  fprintf(fid,"//*** 181) cost 5 = (0,0)(1,1)(1,2)(3,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
   for (k5 = 1; k5 <= sl[0]; k5++) {
    v5d = sc[0][k5];
    f3d = v4d * f1d;
    f3d += v5d * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  181) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 181) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 181) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 181) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 3 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 3 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(1,2)(3,3)(4,4)
//******** Fan-out: 0=2; 1=3; 2=1; 3=2; 4=2; 5=0; 
  printf("//*** 182) cost 5 = (0,0)(1,1)(1,2)(3,3)(4,4)\n");
  fprintf(fid,"//*** 182) cost 5 = (0,0)(1,1)(1,2)(3,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= sl[1]; k2++) {{
    f2d = sc[1][k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[0]; k4++) {
   v4d = sc[0][k4];
  { //*** no loop since fanout=1 for node=2
    f3d = v4d * f1d;
    f3d += f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= slone; k6++) {{
    f4d = scone[k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  182) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 182) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 182) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 182) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 1 2 3 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 1 2 3 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(0,3)(3,4)
//******** Fan-out: 0=3; 1=2; 2=2; 3=2; 4=1; 5=0; 
  printf("//*** 183) cost 5 = (0,0)(1,1)(2,2)(0,3)(3,4)\n");
  fprintf(fid,"//*** 183) cost 5 = (0,0)(1,1)(2,2)(0,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  183) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 183) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 183) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 183) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 0 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 0 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(0,3)(4,4)
//******** Fan-out: 0=3; 1=2; 2=2; 3=1; 4=2; 5=0; 
  printf("//*** 184) cost 5 = (0,0)(1,1)(2,2)(0,3)(4,4)\n");
  fprintf(fid,"//*** 184) cost 5 = (0,0)(1,1)(2,2)(0,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  184) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 184) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 184) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 184) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 0 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 0 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(1,3)(3,4)
//******** Fan-out: 0=2; 1=3; 2=2; 3=2; 4=1; 5=0; 
  printf("//*** 185) cost 5 = (0,0)(1,1)(2,2)(1,3)(3,4)\n");
  fprintf(fid,"//*** 185) cost 5 = (0,0)(1,1)(2,2)(1,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d * f1d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  185) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 185) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 185) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 185) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 1 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 1 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(1,3)(4,4)
//******** Fan-out: 0=2; 1=3; 2=2; 3=1; 4=2; 5=0; 
  printf("//*** 186) cost 5 = (0,0)(1,1)(2,2)(1,3)(4,4)\n");
  fprintf(fid,"//*** 186) cost 5 = (0,0)(1,1)(2,2)(1,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f1d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  186) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 186) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 186) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 186) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 1 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 1 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(2,3)(3,4)
//******** Fan-out: 0=2; 1=2; 2=3; 3=2; 4=1; 5=0; 
  printf("//*** 187) cost 5 = (0,0)(1,1)(2,2)(2,3)(3,4)\n");
  fprintf(fid,"//*** 187) cost 5 = (0,0)(1,1)(2,2)(2,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
   for (k7 = 1; k7 <= sl[0]; k7++) {
    v7d = sc[0][k7];
    f4d = v6d * f2d;
    f4d += v7d * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  187) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 187) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 187) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 187) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 2 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 2 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(2,3)(4,4)
//******** Fan-out: 0=2; 1=2; 2=3; 3=1; 4=2; 5=0; 
  printf("//*** 188) cost 5 = (0,0)(1,1)(2,2)(2,3)(4,4)\n");
  fprintf(fid,"//*** 188) cost 5 = (0,0)(1,1)(2,2)(2,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= sl[1]; k4++) {{
    f3d = sc[1][k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[0]; k6++) {
   v6d = sc[0][k6];
  { //*** no loop since fanout=1 for node=3
    f4d = v6d * f2d;
    f4d += f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  188) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 188) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 188) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 188) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 2 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 2 3 4 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(3,3)(0,4)
//******** Fan-out: 0=3; 1=2; 2=2; 3=2; 4=1; 5=0; 
  printf("//*** 189) cost 5 = (0,0)(1,1)(2,2)(3,3)(0,4)\n");
  fprintf(fid,"//*** 189) cost 5 = (0,0)(1,1)(2,2)(3,3)(0,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  189) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 189) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 189) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 189) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 3 3 0 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 3 3 0 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(3,3)(1,4)
//******** Fan-out: 0=2; 1=3; 2=2; 3=2; 4=1; 5=0; 
  printf("//*** 190) cost 5 = (0,0)(1,1)(2,2)(3,3)(1,4)\n");
  fprintf(fid,"//*** 190) cost 5 = (0,0)(1,1)(2,2)(3,3)(1,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f1d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  190) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 190) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 190) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 190) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 3 3 1 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 3 3 1 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(3,3)(2,4)
//******** Fan-out: 0=2; 1=2; 2=3; 3=2; 4=1; 5=0; 
  printf("//*** 191) cost 5 = (0,0)(1,1)(2,2)(3,3)(2,4)\n");
  fprintf(fid,"//*** 191) cost 5 = (0,0)(1,1)(2,2)(3,3)(2,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f2d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  191) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 191) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 191) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 191) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 3 3 2 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 3 3 2 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(3,3)(3,4)
//******** Fan-out: 0=2; 1=2; 2=2; 3=3; 4=1; 5=0; 
  printf("//*** 192) cost 5 = (0,0)(1,1)(2,2)(3,3)(3,4)\n");
  fprintf(fid,"//*** 192) cost 5 = (0,0)(1,1)(2,2)(3,3)(3,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= sl[1]; k6++) {{
    f4d = sc[1][k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[0]; k8++) {
   v8d = sc[0][k8];
  { //*** no loop since fanout=1 for node=4
    f5d = v8d * f3d;
    f5d += f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  192) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 192) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 192) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 192) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 3 3 3 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 3 3 3 4 sort5\n",difftime(t2, t1));


/*************** Next Graph Info *************************/
//******** cost 5 = (0,0)(1,1)(2,2)(3,3)(4,4)
//******** Fan-out: 0=2; 1=2; 2=2; 3=2; 4=2; 5=0; 
  printf("//*** 193) cost 5 = (0,0)(1,1)(2,2)(3,3)(4,4)\n");
  fprintf(fid,"//*** 193) cost 5 = (0,0)(1,1)(2,2)(3,3)(4,4)\n");
 cost = 5;
 NOFmax = 0;			/**** Compute Maximum NOF sum so far**/
 for (k = 1; k < Bsave; k++)
     if (SumNof[k] > NOFmax) {
         NOFmax = SumNof[k];
      }
 printf("****** %d cost  NOFSmax= %d\n", cost, NOFmax);
 NOFmax+=5; improve = 0; NOFimprove = 0; loops=0;
//******** Main loop starts here *******************
  for (k0 = 1; k0 <= slone; k0++) {{
    f1d = scone[k0];
  of1= oddfund((int) f1d);
  if (NOFmax > of1)
  for (k2 = 1; k2 <= slone; k2++) {{
    f2d = scone[k2] * f1d;
  of2= oddfund((int) f2d);
  if (NOFmax > of2)
  for (k4 = 1; k4 <= slone; k4++) {{
    f3d = scone[k4] * f2d;
  of3= oddfund((int) f3d);
  if (NOFmax > of3)
  for (k6 = 1; k6 <= slone; k6++) {{
    f4d = scone[k6] * f3d;
  of4= oddfund((int) f4d);
  if (NOFmax > of4)
  for (k8 = 1; k8 <= sl[1]; k8++) {{
    f5d = sc[1][k8] * f4d;
  g = (int) f5d; loops+=1; /** output fundamental **/
  gd = f5d; /** output fundamental double precision**/
  if ((gd < B) && (gd > 0))
  if (x[g] >= cost) {
    for (i = 0; i <= 10; i++) newNOF[i] = 0;
    newNOF[1] = of1;
    newNOF[2] = of2;
    newNOF[3] = of3;
    newNOF[4] = of4;
    newNOF[5] = oddfund((int) f5d);
    /** sort array but keep g in place **/
    sort(newNOF, cost - 1);
    newSum = 0;
    for (k = 1; k < cost; k++) newSum += newNOF[k];

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

      if (g == Test) {
        printf("cost new=%d old=%d; SumNOF old=%d  new=%d\n", cost, x[g], SumNof[g], newSum);
        adisp("new NOF after sort", newNOF, 10);}
      /** use as new OF array **/
      for (i = 1; i < 10; i++) nof[g][i] = newNOF[i];

      graph[g] = 40; x[g] = cost; SumNof[g] = newSum;
}}}}}}}}}}}}
if ((NOFimprove == 0) && (improve == 0)) {
    printf("****** Remove this %d cost No Improvements\n", cost);
    fprintf(fid, "****** Remove this %d cost No Improvements\n", cost);
  } else {
    printf("****** Use %d cost ", cost);
    fprintf(fid, "****** Use %d cost", cost);
    printf(" Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
    fprintf(fid, "Improved: %d Graphs NOF = %d\n", improve, NOFimprove);
  }
  loops /= 1000000.0;
  printf("******  193) Actual Loops=%e M\n", loops);
  fprintf(fid, "****** 193) Actual Loops=%e M\n", loops);
  t1 = t2;
  time(&t2);
  printf("Time 193) this block =%f sec. Total =%f \n",  difftime(t2, t1), difftime(t2, t0));
  fprintf(fid, "Time 193) this block =%f sec. Total =%f \n", difftime(t2, t1), difftime(t2, t0));
  printf("%07.1f c5 0 0 1 1 2 2 3 3 4 4 sort5\n",difftime(t2, t1));
  fprintf(fid,"%07.1f c5 0 0 1 1 2 2 3 3 4 4 sort5\n",difftime(t2, t1));


 LUTcheck();//****** function call check

 MAGsave(10);//****** function call save

 found(5);//****** function call find

 find(6);
}