#usage "<qt><b>Statistic Table of Elements in the Layout</b><p>\n"
       "To change the units in the table, please use the variable uval,\n"
       "which can be found in the ulp file.<p>\n"
       "THIS PROGRAM IS PROVIDED AS IS AND WITHOUT WARRANTY OF ANY KIND, "
       "EXPRESSED OR IMPLIED.<p>\n"
       "<author>Author: alf@cadsoft.de</author></qt>"

#require 5.0400

// 2005-01-12 - Check if layer Top or Bottom used as Power-Plane *** alf@cadsoft.de
// 2005-07-05 - Calculate used area of packages. Use pads, smds and elements in
//              Layer 21/51 to calculate the used area of package.
//              Rotation of packages are not consider
// 2005-07-19 - Polygon-Rank
// 2005-11-17 - List all defined Layers
// 2005-12-01 - List same Values && Packages && Layer
// 2005-12-08 - List Signals without connection (PAD/SMD) as False-Signals
// 2006-04-28 - Mask Layer
// 2006-09-26 - Circle in Copper-Layer and Text in Place-Layer
// 2006-10-05 - List first Wire coordinate of Flase Signals if exist
// 2007-12-04 - Corrected Class handling to select net-list if classes empty
// 2007-12-19 - Locked & Unlocked Packages
// 2009-02-11 - save also false signals, and rudimentarily signal name in report
//              # rudimentary signal names can produced by older eagle version
// 2009-07-15 - Check Polygon in Supply-Layer $name
// 2009-10-15 - separate drill statistic by via stack
// 2009-12-02 - separate packages with and without contacts
//

string Version = "Version 1.2.1";   // 2009-12-02

int    uval = 1;
string unit[] = { "Micron", "mm", "Mil", "Inch" };
int    unitPrec[] = { 0, 1, 1, 3 }, RoundFactor = pow(10, unitPrec[uval]);

string minvalfile = filesetext(argv[0], "-checkmin.val");
real   checkMinWire = 0.3;
real   checkMinArc = checkMinWire;
real   checkMinCirc = checkMinWire;
real   checkMinPoly = checkMinWire;
real   checkMinRestringP = checkMinWire;
real   checkMinRestringV = checkMinWire;
real   checkMinClearance = 0.3;
real   checkMinIsol = checkMinClearance;
real   checkMinPadDrill = 0.6;
real   checkMinViaDrill = checkMinPadDrill;
real   checkMinHoleDrill = checkMinPadDrill;
string checkSupplyLayerPolygon = "";     // 2009-07-15
string SupplyLayerName[];
int    SupplyLayers[];
int    SupplyLayersUsedPolygons[];
string showminValWidth;
string showminValOther;

string LabelcntRECT;
string LabelcntCIRCLE;
string LabelcntTextSize;
string LabelcntTextWidth;
string LabelcntPlaceTextSize;
string LabelcntPlaceTextWidth;

int    maxX = INT_MIN;
int    minX = INT_MAX;
int    maxY = INT_MIN;
int    minY = INT_MAX;

string wireWidthInternal = " * Wire width are saved in 0.2 micron resolution.\n";

int    WireWidth[];
int    cWireWidth[];
int    cntWire = 0;

int    ArcWidth[];
int    cArcWidth[];
int    cntArc = 0;

// ******************************************************************
// *** WIRE WIDTH wird nur geradzahlig gespeichert, wegen Teilung *** az
// ******************************************************************
string PolygonLayer[] = { "" , ""};
int    cPolygonL = 0;
int    PolygonWidth[];
int    cPolygonWidth[];
int    cntPolyW = 0;

string PolygonSignalName[];
int    PolygonIsolate[];
int    PolygonRank[];
int    cPolygonIsolate[];
int    cntPolyIso = 0;
int    PolyWidthError = 0;
string PolygonError = "";

int    cntLayer = 0;
string usedLayer;
int    cntalllay;
string allLayers[];
string layerError;
string displayLayerError;
real   outlines = 0;
string brdoutline;
string brdmaximum = "max. Board length ?\n(layer 20 empty)";

string NetClassName[];
int    NetClassWidth[];
int    NetClassClear[];
int    NetClassDrill[];
int    NetClassNr[];
int    selNetClassNr[];
int    cNetClass[];

string SignalName[];
int    SignalClass[];
string SignalClassList[];
int    SignalClassSelect = 0;
int    SignalCnt = 0;
int    SignalUnrouted = 0;
string Unrouted = "";

string falseSignalList[];  // only signal if connected to pad or smd is a true signal 2005-12-08 alf@cadsoft.de
string FalsWxy[];          // 2006-10-05 coordiante of 1. wire segment if false signal
int    falseSignalCnt = 0;
int    cntfalseSignalVias[];
int    cntfalseSignalWires[];      // 2009-02-11
string deleteRudimentalSignalName = "";  // 2009-02-12

int    cnt_pad_on_signal = 0;

int    SMDx[], SMDy[];
int    cSMD[];
int    cntSMDt = 0;
int    cntSMDb = 0;
int    cntSMD = 0;

int    CirclWidth[];
int    cCirclWidth[];
int    cntCircl = 0;
int    CirclDiam[];
int    cCirclDiam[];
int    cntCirclDiam = 0;

int    RECTx[];
int    RECTy[];
int    cRECT[];
int    cntRECT = 0;

int    CIRCLEx[];
int    CIRCLEy[];
int    cCIRCLE[];
int    cntCIRCLE = 0;


int    TextWidth[];
int    cTextWidth[];
int    cntTextWidth = 0;
int    TextSize[];
int    cTextSize[];
int    cntTextSize = 0;

int    PlaceTextWidth[];
int    cPlaceTextWidth[];
int    cntPlaceTextWidth = 0;
int    PlaceTextSize[];
int    cPlaceTextSize[];
int    cntPlaceTextSize = 0;


int    PadDrill[];
int    cPadDrill[];
int    cntPDril = 0;

int    PadDiameterTOP[];
int    cPadDiameterTOP[];
int    cntPDiamTOP = 0;
int    PadDiameterBOT[];
int    cPadDiameterBOT[];
int    cntPDiamBOT = 0;
int    iPadDiameter[];  // inner Layer
int    ciPadDiameter[];
int    cntiPDiam = 0;

int    PadRestringTOP[];
int    cPadRestringTOP[];
int    cntPringTOP;
int    PadRestringBOT[];
int    cPadRestringBOT[];
int    cntPringBOT;
int    PadRestringI[];
int    cPadRestringI[];
int    cntPringI = 0;

int    ViaDrill[];
int    cViaDrill[];
int    cntVDril = 0;

int    ViaDiameter[];
int    cViaDiameter[];
int    cntVDiam = 0;

int    ViaDiameterI[];
int    cViaDiameterI[];
int    cntVDiamI = 0;

int    ViaRestringO[],  ViaRestringI[];
int    cViaRestringO[], cViaRestringI[];
int    cntVringO = 0,   cntVringI = 0;

int    ViaStackCnt[];
string ViaStack[];
int    cntStack = 0;
string StackDrills[];  // 2009-10-15
string showStackDrills[];

int    Hole[];
int    cHole[];
int    cntHole = 0;

string drillRack[];
real   Drilling[];
int    imax = 0;

string Lbr[];
int    cLbr[];
int    cntLbr = 0;

string PacName[];
int    cPacName[];
int    cntPacName = 0;
// --- same Value and Package and Layer --- 2005-12-01 alf@cadsoft.de
int    cntEVPL = 0;
string EVALpac[];
string EvalPAC[];
int    cEVPL[], cEVPL1[], cEVPL16[];


int    emptyValue = 0;
string empty = "~/-empty-/~";

int    cntElement = 0;
string Ename[];
int    ELocked[];
int    cntLocked = 0;
real   eUsedArea[];  // calculate over xPlace/xDocu/PAD/SMD  12.05.2005 alf@cadsoft.de
int    eUsedLayer[];
real   summary_area = 0;

string EContact[];  // 2009-12-02
int    cntCont = 0;
string EnoContact[];
int    cntNoCont = 0;


int    art_selected = 0;
int    LBRselected;
int    PACselected;
int    pac_drill[], cntpac_drill[], cnt_d;
int    pac_hole[], cntpac_hole[], cnt_h;
int    VALselected;
string Element_info = " \n \n \n";
string linfo = "<nobr><font color=darkgreen>&nbsp;Double click in listings<br> for detailed info</font></nobr>";

string sum;
   int sumSignals = 0;
   int sumWires = 0;
   int minWires = INT_MAX;
   int sumARCw = 0;
   int minARCw = INT_MAX;
   int sumCIRCw = 0;
   int minCIRCw = INT_MAX;
   int sumCIRCdiam = 0;
   int minCIRCdiam = INT_MAX;
   int sumRECT = 0;
   int minRECTx = INT_MAX;
   int minRECTy = INT_MAX;
   int minClearance = INT_MAX;
   int sumPOLYw = 0;
   int minPOLYw = INT_MAX;
   int sumISOL = 0;
   int minISOL = INT_MAX;
   int sumSMD = 0;
   int minSMDx = INT_MAX;
   int minSMDy = INT_MAX;
   int sumPADdril = 0;
   int minPADdril = INT_MAX;
   int sumPADdia = 0;
   int minPADdia = INT_MAX;
   int sumPADdiaI = 0;
   int minPADdiaI = INT_MAX;
   int sumPADrest = 0;
   int minPADrest = INT_MAX;
   int sumPADrestI = 0;
   int minPADrestI = INT_MAX;
   int sumVIAdril = 0;
   int minVIAdril = INT_MAX;
   int sumVIAdiam = 0;
   int minVIAdiam = INT_MAX;
   int sumVIAdiamI = 0;
   int minVIAdiamI = INT_MAX;
   int sumVIArest = 0;
   int minVIArest = INT_MAX;
   int sumVIArestI = 0;
   int minVIArestI = INT_MAX;
   int sumHOLE = 0;
   int minHOLE = INT_MAX;
   int sumTEXTw = 0;
   int minTEXTw = INT_MAX;
   int sumPlaceTEXTw = 0;
   int minPlaceTEXTw = INT_MAX;


   int padlSTOP[];  // Mask in Package 2006-04-28
   int smdlSTOP[];  // Mask in Package
   int smdlCREAM[]; // Mask in Package
   int lSTOPpac[];     // Mask in Package
   int lSTOPbrd[];     // Mask in Board
   int lCREAMpac[];    // Mask in Package
   int lCREAMbrd[];    // Mask in Board
   int msort = 0;

int indexWire[],
    indexPolygonWidth[],
    indexPolygonIsolate[],
    indexSMD[],
    indexPadDrill[],
    indexPadDia[],
    indexiPadDia[],
    indexPadRestring[],
    indexPadRestringI[],
    indexViaDrill[],
    indexViaRestringO[],
    indexViaRestringI[],
    indexViaDiameter[],
    indexViaDiameterI[],
    indexHole[],
    indexArcW[],
    indexCirclW[],
    indexTextWidth[],
    indexPlaceTextWidth[];

numeric string statisticWirew[];
numeric string statisticPolyw[];
numeric string statisticPoliso[];
numeric string statisticCLASS[];
numeric string statisticFalseSignals[];
numeric string statisticSMD[];
numeric string statisticPADdril[];
numeric string statisticPADdiaTOP[];
numeric string statisticPADdiaBOT[];
numeric string statisticPADdiaI[];
numeric string statisticPADrestTOP[];
numeric string statisticPADrestBOT[];
numeric string statisticPADrestI[];
numeric string statisticVIAdril[];
numeric string statisticVIAdia[];
numeric string statisticVIAdiaI[];
numeric string statisticVIArest[];
numeric string statisticVIArestI[];
numeric string statisticVIAstack[];
numeric string statisticHOLE[];
numeric string statisticARCw[];
numeric string statisticCIRw[];
numeric string statisticCIRdiam[];
numeric string statisticRECT[];
numeric string statisticTEXTw[];
numeric string statisticTEXTsize[];
numeric string statisticPlaceTEXTw[];
numeric string statisticPlaceTEXTsize[];
numeric string statisticLBR[];
numeric string statisticPAC[];
//numeric string statisticVALUE[]; 2005.12.02 gecancelt
numeric string statisticValPacLay[];

string  statisticLocked;
string statisticSTOP_CREAM[];

string Text;

string ulp_path;
char bkslash = '/';
int pos = strrchr(argv[0], bkslash);
if (pos >= 0) ulp_path = strsub(argv[0], 0, pos + 1);

string attention = "<img src=statistic_attention_min_value.bmp>";

string brdfile;


// Functions

real u2u(int v) {
  switch (uval) {
    case GRID_UNIT_MIC  : return u2mic(v);
      break;

    case GRID_UNIT_MM	: return u2mm(v);
      break;

    case GRID_UNIT_MIL  : return u2mil(v);
      break;

    case GRID_UNIT_INCH : return u2inch(v);
      break;
  }
}


string value(int v, string is) {
  if (v == INT_MAX) return "<i>not used</i> " + is;
  string sv;
  switch (uval) {
    case GRID_UNIT_INCH : sprintf(sv, "%.6f %s", u2inch(v), is);
                          break;

    case GRID_UNIT_MIL  : sprintf(sv, "%.3f %s", u2mil(v), is);
                          break;

    case GRID_UNIT_MM   : sprintf(sv, "%.4f %s", u2mm(v), is);
                          break;

    case GRID_UNIT_MIC  : sprintf(sv, "%.1f %s", u2mic(v), is);
                          break;
  }
  return sv;
}


string min_value(int v, real minv) {
  string sv = "<p>";
  switch (uval) {
    case GRID_UNIT_INCH : if(u2inch(v) < minv) {
                          sprintf(sv, "%s &lt; %.4f<p>", attention, minv );
                          }
                          break;

    case GRID_UNIT_MIL  : if(u2mil(v) < minv) {
                          sprintf(sv, "%s &lt; %.4f<p>", attention, minv );
                          }
                          break;

    case GRID_UNIT_MM   : if(u2mm(v) < minv) {
                          sprintf(sv, "%s &lt; %.4f<p>", attention, minv );
                          }
                          break;

    case GRID_UNIT_MIC  : if(u2mic(v) < minv) {
                          sprintf(sv, "%s &lt; %.4f<p>", attention, minv );
                          }
                          break;
  }
  return sv;
}


string check_min_ValueWidth(void) {
  string sh;
  sprintf(sh, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
         value(minWires, " - Wire width "),
         min_value(minWires, checkMinWire),
         value(minPOLYw, " - Polygon wire width"),
         min_value(minPOLYw, checkMinPoly),
         value(minARCw, " - Arc width "),
         min_value(minARCw, checkMinArc),
         value(minCIRCw, " - Circle width "),
         min_value(minCIRCw, checkMinCirc),
         value(minPADrest, " - Pad Restring "),
         min_value(minPADrest, checkMinRestringP),
         value(minVIArest, " - Via Restring "),
         min_value(minVIArest, checkMinRestringV),
         value(minClearance, " - Clearance "),
         min_value(minClearance, checkMinClearance),
         value(minISOL, " - Isolate Polygon "),
         min_value(minISOL, checkMinIsol)
         );
  return sh;
}

string check_min_ValueOther(void) {
  string sh;
  sprintf(sh, "%s%s%s%s%s%s%s%s%s%s%s%s%s",
         value(minTEXTw, " - Text width ") + "<p>",
         value(minSMDx, " - SMD X ") + "<p>",
         value(minSMDy, " - SMD Y ") + "<p>",
         value(minPADdril, " - Pad drill "),
         min_value(minPADdril, checkMinPadDrill),
         value(minPADrestI, " - Pad Restring Inner.<p>"),
         value(minVIAdril, " - Via drill "),
         min_value(minVIAdril, checkMinViaDrill),
         value(minVIArestI, " - Via Restring Inner.<p>"),
         value(minHOLE, " - Hole drill "),
         min_value(minHOLE, checkMinHoleDrill),
         value(minRECTx, " - Rectangle X ") + "<p>",
         value(minRECTy, " - Rectangle Y ")
         );
  return sh;
}

void AddDrilling(int Size) {
  real x;
  switch (uval) {
    case GRID_UNIT_MIC  :   x = round(u2mic(Size) * RoundFactor) / RoundFactor;
                         break;
    case GRID_UNIT_MM   :   x = round(u2mm(Size) * RoundFactor) / RoundFactor;
                         break;
    case GRID_UNIT_MIL  :   x = round(u2mil(Size) * RoundFactor) / RoundFactor;
                         break;
    case GRID_UNIT_INCH : x = round(u2inch(Size) * RoundFactor) / RoundFactor;
                         break;
  }

  for (int i = imax; --i >= 0; )
      if (Drilling[i] == x)
         return;
  Drilling[imax++] = x;
  return;
}

void loadminval(void) {
  string line[];
  int lines = fileread(line, minvalfile);
  checkMinWire      = strtod(line[0]);
  checkMinArc       = strtod(line[1]);
  checkMinCirc      = strtod(line[2]);
  checkMinPoly      = strtod(line[3]);
  checkMinRestringP = strtod(line[4]);
  checkMinRestringV = strtod(line[5]);
  checkMinClearance = strtod(line[6]);
  checkMinIsol      = strtod(line[7]);
  checkMinPadDrill  = strtod(line[8]);
  checkMinViaDrill  = strtod(line[9]);
  checkMinHoleDrill = strtod(line[10]);
  return;
}


void saveminval(void) {
  output( minvalfile, "wt") {
    printf("%.4f\n%.4f\n%.4f\n%.4f\n%.4f\n%.4f\n%.4f\n%.4f\n%.4f\n%.4f\n%.4f",
         checkMinWire,
         checkMinArc,
         checkMinCirc,
         checkMinPoly,
         checkMinRestringP,
         checkMinRestringV,
         checkMinClearance,
         checkMinIsol,
         checkMinPadDrill,
         checkMinViaDrill,
         checkMinHoleDrill );
  }
  return;
}

void GetCheckValues(void) {
  dlgDialog("Checked min values") {
    dlgGridLayout {
         dlgCell( 0, 0) dlgRealEdit( checkMinWire, 0, 10);
         dlgCell( 0, 1) dlgLabel("Check minimum Wire width");
         dlgCell( 1, 0) dlgRealEdit( checkMinArc, 0, 10);
         dlgCell( 1, 1) dlgLabel("Check minimum ARC width");
         dlgCell( 2, 0) dlgRealEdit( checkMinCirc, 0, 10);
         dlgCell( 2, 1) dlgLabel("Check minimum Circle width");
         dlgCell( 3, 0) dlgRealEdit( checkMinPoly, 0, 10);
         dlgCell( 3, 1) dlgLabel("Check minimum Polygon width");
         dlgCell( 4, 0) dlgRealEdit( checkMinRestringP, 0, 10);
         dlgCell( 4, 1) dlgLabel("Check minimum Pad Restring width");
         dlgCell( 5, 0) dlgRealEdit( checkMinRestringV, 0, 10);
         dlgCell( 5, 1) dlgLabel("Check minimum Via Restring width");
         dlgCell( 6, 0) dlgRealEdit( checkMinClearance, 0, 10);
         dlgCell( 6, 1) dlgLabel("Check minimum Clearance");
         dlgCell( 7, 0) dlgRealEdit( checkMinIsol, 0, 10);
         dlgCell( 7, 1) dlgLabel("Check minimum Polygon Isolate");
         dlgCell( 8, 0) dlgRealEdit( checkMinPadDrill, 0, 10);
         dlgCell( 8, 1) dlgLabel("Check minimum Pad drill");
         dlgCell( 9, 0) dlgRealEdit( checkMinViaDrill, 0, 10);
         dlgCell( 9, 1) dlgLabel("Check minimum Via drill");
         dlgCell(10, 0) dlgRealEdit( checkMinHoleDrill, 0, 10);
         dlgCell(10, 1) dlgLabel("Check minimum Hole drill");
    }
    dlgLabel("All Units = " + unit[uval]);

    dlgHBoxLayout {
      dlgPushButton("+OK") {
        dlgAccept();
        showminValWidth = check_min_ValueWidth();
        showminValOther = check_min_ValueOther();
      }
      dlgPushButton("&Save") saveminval();
      dlgPushButton("&Load") loadminval();
      dlgPushButton("-Cancel") dlgReject();
      dlgStretch(1);
    }
  };
  return;
}

string makestrg(string s) {
  string rs;
  return rs;
}

string saveReport(void) {
  int t = time();
  int n;
  string report = "Data Exported from: ";
  report +=  brdfile + "\n";
  report += "with: " + argv[0] + "\n";
  report += "at: " + t2string(t) + "\n";
  report += EAGLE_SIGNATURE + "\n\n";
  report += "all Values in " + unit[uval] + "\n";
  report += brdmaximum + "\n";
  report += brdoutline + "\n\n";
  report += usedLayer + "_________________________\n";
  if (layerError) report += layerError;
  report += "\n";
  report += sum + "\n";
  report += "\n============================\n";   n=0;
  if (Unrouted) report += Unrouted + " Unroutet airwires ***\n";

  report += "\n----------------------------\nLAYER\n";   n=0;
  sort(cntalllay, allLayers);
  report += "Nb.\tName\tUsed\n";
  for (n = 0; n < cntalllay; n++) {
    report+= allLayers[n] + "\n";
  }
  report += "\n----------------------------\nCLASS\n";   n=0;
  while (statisticCLASS[n]) {
     report += statisticCLASS[n] + "\n";      n++;
  }
  report += "\n----------------------------\nWIDTH\n";   n=0;
  while (statisticWirew[n]) {
    report += statisticWirew[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticARCw[n]) {
    report += statisticARCw[n] + "\n";      n++;
  }
  report += wireWidthInternal;

  report += "\n";   n=0;
  while (statisticPolyw[n]) {
    report += statisticPolyw[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticPoliso[n]) {
    report += statisticPoliso[n] + "\n";      n++;
  }
  report += "\nPolygon\n";   n=0;
  report += "Type\tName\tLayer\tRank\tWidth\n";
  while (PolygonLayer[n]) {
    report += PolygonLayer[n] + "\n";      n++;
  }
  if (PolyWidthError) report += PolygonError + "\n";

  report += wireWidthInternal;
  report += "\n----------------------------\n";   n=0;
  while (statisticCIRw[n]) {
    report += statisticCIRw[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticCIRdiam[n]) {
    report += statisticCIRdiam[n] + "\n";      n++;
  }
  report += "\n----------------------------\n";   n=0;
  while (statisticTEXTw[n]) {
    report += statisticTEXTw[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticTEXTsize[n]) {
    report += statisticTEXTsize[n] + "\n";      n++;
  }
  report += "\n----------------------------\n";   n=0;
  while (statisticSMD[n]) {
    report += statisticSMD[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticPADdiaTOP[n]) {
    report += statisticPADdiaTOP[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticPADdiaBOT[n]) {
    report += statisticPADdiaBOT[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticPADrestTOP[n]) {
    report += statisticPADrestTOP[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticPADrestBOT[n]) {
    report += statisticPADrestBOT[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticPADdiaI[n]) {
    report += statisticPADdiaI[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticPADrestI[n]) {
    report += statisticPADrestI[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticVIAdia[n]) {
    report += statisticVIAdia[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticVIArest[n]) {
    report += statisticVIArest[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticVIAdiaI[n]) {
    report += statisticVIAdiaI[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticVIArestI[n]) {
    report += statisticVIArestI[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticVIAdril[n]) {
    report += statisticVIAdril[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticVIAstack[n]) {
    report += statisticVIAstack[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticPADdril[n]) {
    report += statisticPADdril[n] + "\n";      n++;
  }
  report += "\n----------------------------\n";   n=0;
  while (statisticHOLE[n]) {
    report += statisticHOLE[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (drillRack[n]) {
    report += drillRack[n] + "\n";      n++;
  }
  report += "\n----------------------------\n";   n=0;
  while (statisticLBR[n]) {
    report += statisticLBR[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticPAC[n]) {
    report += statisticPAC[n] + "\n";      n++;
  }
  report += "\n";   n=0;
  while (statisticValPacLay[n]) {
    report += statisticValPacLay[n] + "\n", n++;
  }
  report += "\n----------------------------\n";   n=0;
  while (statisticRECT[n]) {
    report += statisticRECT[n] + "\n";      n++;
  }
  report += LabelcntRECT + "\n";

  report += "\n----------------------------\n";   n=0;
  while (statisticTEXTsize[n]) {
    report += statisticTEXTsize[n] + "\n";      n++;
  }
  report += LabelcntTextSize + "\n";

  report += "\n";   n=0;
  while (statisticTEXTw[n]) {
    report += statisticTEXTw[n] + "\n";      n++;
  }
  report += LabelcntTextWidth + "\n";

  report += "\n";   n=0;
  while (statisticPlaceTEXTsize[n]) {
    report += statisticPlaceTEXTsize[n] + "\n";      n++;
  }
  report += LabelcntPlaceTextSize + "\n";

  while (statisticPlaceTEXTw[n]) {
    report += statisticPlaceTEXTw[n] + "\n";      n++;
  }
  report += LabelcntPlaceTextWidth + "\n";

  report += "\n";   n=0;
  while (statisticCIRdiam[n]) {
    report += statisticCIRdiam[n] + "\n";      n++;
  }
  report += LabelcntCIRCLE + "\n";

  report += "\n";
  if (falseSignalCnt) {
    report += "False signals:\n"; // 2009-02-11
    for (n = 0; n < falseSignalCnt; n++) {
      report += statisticFalseSignals[n]+"\n";
    }
  }
  if (deleteRudimentalSignalName) {  // 2009-02-12
    report += "\n";
    report += "Rudimentarily signal name(s):\n";
    report += deleteRudimentalSignalName;
    report += "\n";
  }
  report += "End report";
  report += "\n";
  return report;
}


void drillStackRack(int rack, real drill) { // 2009-10-15 missing 2cnd dimension for array, realize by string(split)
  string d[];
  real Drills[];
  int  cDrills[];
  int cntDrills = strsplit(d, StackDrills[rack], '\t') / 2;  // definition : drill \t count \t drill \t count ....
  int found = 0;
  int n;
  for (n = 0; n < cntDrills; n++) {
    Drills[n]  = strtod(d[n*2]);
    cDrills[n] = strtol(d[n*2+1]);
    if (Drills[n] == drill){
      cDrills[n]++;
      found = 1;
    }
  }
  if (!found) {
    Drills[cntDrills] = drill;
    cDrills[cntDrills]++;
    cntDrills++;
  }
  string s;
  StackDrills[rack] = ""; // clear string to generate new, with new counter
  for (n = 0; n < cntDrills; n++) {
    sprintf(s, "%.2f\t%d\t", Drills[n], cDrills[n]);
    StackDrills[rack]+=s;
  }
  return;
}


void showLayerRack(int sel) {
  string d[];
  int cntDrills = strsplit(d, StackDrills[sel], '\t') / 2;  // definition : drill \t count \t drill \t count ....
  showStackDrills[0] = "";
  int n;
  for (n = 0; n < cntDrills; n++) {
    sprintf(showStackDrills[n], "%s\t%s", d[n*2], d[n*2+1]);
  }
  showStackDrills[n] = ""; // clear last string
  return;
}


void  viaStackRack(int start, int end, real drill) {  // 2009-10-15 new drill
  string sstack = "";
  sprintf(sstack, "%02d-%02d", start, end);
  int notfound = 1;
  int stc = 0;
  for (stc = 0; stc < cntStack; stc ++) {
    if (sstack == ViaStack[stc]) {
      drillStackRack(stc, drill);          // 2009-10-15 add drill to stack rack
      ViaStackCnt[stc]++;
      notfound = 0;
      break;
    }
  }
  if (notfound) {
    ViaStack[cntStack] = sstack;           // 2009-10-15 add drill to stack rack
    drillStackRack(cntStack, drill);       // cound drill
    ViaStackCnt[cntStack]++;
    cntStack++;
  }
  return;
}


real WireLength(int x1, int x2, int y1, int y2) {
  return sqrt( pow(u2u(x2) - u2u(x1), 2) + pow( u2u(y2) - u2u(y1), 2));
}


real WireLengthCircle(real r) {
  return u2u(r * 2 * PI) ;
}


real WireLengthArc(real startangle, real endangle, int r) {
  return u2u(r * 2 * PI) / 360 * (endangle - startangle);
}


void checkmaxmin(int x1, int x2, int y1, int y2, int width) {
  int w = 0;
  if (width) w = width/2;  // 2005-07-05 alf
  if (x1 > maxX) maxX = x1+w;
  if (x2 > maxX) maxX = x2+w;
  if (y1 > maxY) maxY = y1+w;
  if (y2 > maxY) maxY = y2+w;
  if (x1 < minX) minX = x1-w;
  if (x2 < minX) minX = x2-w;
  if (y1 < minY) minY = y1-w;
  if (y2 < minY) minY = y2-w;
  return;
}

void checkHole( int x, int y, int drill ) {
  checkmaxmin( x - drill/2, x + drill/2, y - drill/2, y + drill/2 , 0);
  return;
}


void checkarc( int x1, int x2, int y1, int y2, int xc, int yc, real angle1, real angle2, real radius, int width) {
  checkmaxmin( x1, x2, y1, y2, width );
  if     ( angle2 > angle1 + 270.0) {
    if     ( angle1 < 90  ) checkmaxmin( x1         , xc - radius, yc + radius, yc - radius, width );
    else if( angle1 < 180 ) checkmaxmin( xc - radius, xc + radius, y1         , yc - radius, width );
    else if( angle1 < 270 ) checkmaxmin( x1         , xc + radius, yc - radius, yc + radius, width );
    else if( angle1 < 360 ) checkmaxmin( xc + radius, xc - radius, y1         , yc + radius, width );
  }
  else if( angle2 > angle1 + 180.0) {
    if     ( angle1 < 90  ) checkmaxmin( x1         , xc - radius, yc + radius, y2         , width );
    else if( angle1 < 180 ) checkmaxmin( x1         , xc - radius, yc - radius, y2         , width );
    else if( angle1 < 270 ) checkmaxmin( x1         , xc + radius, yc - radius, y2         , width );
    else if( angle1 < 360 ) checkmaxmin( x1         , xc + radius, yc + radius, y2         , width );
  }
  else if( angle2 > angle1 + 90.0 ) {
    if     ( angle1 < 90  ) checkmaxmin( x1         , x2         , yc + radius, y2         , width );
    else if( angle1 < 180 ) checkmaxmin( x1         , xc - radius, y1         , y2         , width );
    else if( angle1 < 270 ) checkmaxmin( x1         , x2         , yc - radius, y2         , width );
    else if( angle1 < 360 ) checkmaxmin( x1         , xc + radius, y1         , y2         , width );
  }
  return;
}


void checkpad( int x, int y, int diameter1, int diameter16, int shape1, int shape16, int P_elongation) {
  int d = diameter1;
  int d2 = diameter1 / 2;
  if (shape16 == PAD_SHAPE_LONG)   d = diameter1 * (diameter1 * P_elongation / 100);
  if (shape16 == PAD_SHAPE_OFFSET) d = diameter1 * (diameter1 * P_elongation / 100) * 1.5;
  checkmaxmin( x + d2, x - d2, y + d2, y - d2, 0 );
  return;
}


void checksmd( int x, int y, int smddx, int smddy, int Layer) {
  int dx2 = smddx / 2;
  int dy2 = smddx / 2;
  checkmaxmin( x + dx2, x - dx2, y + dy2, y - dy2, 0 );
  return;
}


real ArcLength(real ang1, real ang2, real radius) {
  return radius  * 2 * PI / 360 * (ang2 - ang1);
}


string NetClassLabel(string ClassName , int cnt) {
  string s;
  sprintf(s, "CLASS %s : %d Netze", ClassName , cnt);
  return s;
}


string isempty(string s) {
  if (!s) s = empty;
  return s;
}


void list_pac_drills(int drill) {
  int n;
  for ( n = 0; n <= cnt_d; n++) {
    if (pac_drill[n] == drill) {
      cntpac_drill[n]++;
      break;
    }
  }
  if (n > cnt_d) {           // a new drill
    cnt_d++;
    pac_drill[cnt_d] = drill;
    cntpac_drill[cnt_d]++;
    pac_drill[cnt_d+1] = 0;
  }
  return;
}


void list_pac_holes(int drill) {
  int n;
  for ( n = 0; n <= cnt_h; n++) {
    if (pac_hole[n] == drill) {
      cntpac_hole[n]++;
      break;
    }
  }
  if (n > cnt_h) {           // a new drill
    cnt_h++;
    pac_hole[cnt_h] = drill;
    cntpac_hole[cnt_h]++;
    pac_hole[cnt_h+1] = 0;
  }
  return;
}


string infoDril(UL_ELEMENT E) {
  string s, h;
  cnt_d = -1;
  cnt_h = -1;
  cntpac_drill[0] = 0;
  cntpac_hole[0] = 0;
  E.package.holes(H) list_pac_holes(H.drill);

  if (cnt_d > -1) {
    s += "Drills:\n";
    for (int n = 0; n <= cnt_d; n++) {
      sprintf(h, "%d\t%.4f mm\n", cntpac_drill[n], u2mm(pac_drill[n]) );
      s += h;
    }
  }
  if (cnt_h > -1) {
    s += "Holes:\n";
    for (int n = 0; n <= cnt_h; n++) {
      sprintf(h, "%d\t%.4f mm\n", cntpac_hole[n], u2mm(pac_hole[n]) );
      s += h;
    }
  }
  if (cnt_d > -1 || cnt_h > -1) s += "------\n";
  return s;
}

void infoLBR( string val) {
  linfo = "Element : Value : Package";
  string s, M;
  board(B) {
    B.elements(E) {
      if (E.package.library == val) {
        sprintf(s, "%s %s(%.3f %.3f)\t: %s\t: %s\n", E.name, M, u2u(E.x), u2u(E.y), isempty(E.value), E.package.name);
        Element_info += s;
      }
    }
  }
  return;
}

void infoPAC( string val) {
  linfo = "Element : Value : Library";
  string s, M;
  int getdrill = 0;
  board(B) B.elements(E) if (E.package.name == val) {
    if (E.mirror) M = "Bot ";
    else M = "Top ";
    if (!getdrill) {
      Element_info += infoDril(E);
      getdrill++;
    }
    sprintf(s, "%s %s(%.3f %.3f)\t: %s\t: %s\n", E.name, M, u2u(E.x), u2u(E.y), isempty(E.value), E.package.library);
    Element_info += s;
  }
  return;
}


void infoVAL( string val) {
  string s, M;
  int pos = strstr(val, empty);
  if (pos == 0) {
    linfo = "Package : Library";
    val = strsub(val, strlen(empty));
    board(B) B.elements(E) if (E.name == val) {
      sprintf(Element_info, "Value empty/leer\n");
      if (E.mirror) M = "Bot ";
      else M = "Top ";
      sprintf(s, "%s %s(%.3f %.3f) %s\t: %s\n", E.name, M, u2u(E.x), u2u(E.y), E.package.name, E.package.library);
      Element_info += s;
    }

  }
  else {
    linfo = "Element : Package : Library";
    board(B) B.elements(E) if (E.value == val) {
      if (E.mirror) M = "Bot ";
      else M = "Top ";
      sprintf(s, "%s %s(%.3f %.3f)\t: %s\t: %s\n\n", E.name, M, u2u(E.x), u2u(E.y), E.package.name, E.package.library);
      Element_info += s;
    }
  }
  return;
}


void get_Info(int art, string val) {
  Element_info = "";
  int pos = strchr(val, '\t', 0);
  val = strsub(val, 0, pos);
  switch(art) {
    case 1  : infoLBR(val);
              break;

    case 2  : infoPAC(val);
              break;

    case 3  : infoVAL(val);
              break;

    default : break;
  }
  return;
}


void resetMaxMin(void) {
  maxX = INT_MIN;
  minX = INT_MAX;
  maxY = INT_MIN;
  minY = INT_MAX;
  return;
}


// *** used area in board to calculate if board area enuff ***

real used_area(UL_ELEMENT E) {
  resetMaxMin();
  E.package.circles(C) {
    if (C.layer == 1 || C.layer == 16 || C.layer == 21 ||  C.layer == 22 ||  C.layer == 51 ||  C.layer == 52 )
        checkmaxmin( C.x - C.radius, C.x + C.radius, C.y - C.radius, C.y + C.radius, C.width );
  }
  E.package.wires(W) {
    if (W.layer == 1 || W.layer == 16 || W.layer == 21 ||  W.layer == 22 ||  W.layer == 51 ||  W.layer == 52 ) {
      if (W.arc) {
        checkarc(W.arc.x1, W.arc.x2, W.arc.y1, W.arc.y2, W.arc.xc, W.arc.yc, W.arc.angle1, W.arc.angle2, W.arc.radius, W.width);
      }
      else  checkmaxmin( W.x1, W.x2, W.y1, W.y2, W.width );
    }
  }
  E.package.contacts(CON) {
    if (CON.pad) checkpad(CON.pad.x, CON.pad.y, CON.pad.diameter[1], CON.pad.diameter[16], CON.pad.shape[1], CON.pad.shape[16], CON.pad.elongation);
    else         checksmd(CON.smd.x, CON.smd.y, CON.smd.dx[CON.smd.layer], CON.smd.dy[CON.smd.layer], CON.smd.layer);
  }
  E.package.holes(H)  checkHole( H.x, H.y, H.drill );
  E.package.rectangles(R) {
    if (R.layer == 1 || R.layer == 16 || R.layer == 21 ||  R.layer == 22 ||  R.layer == 51 ||  R.layer == 52 )
        checkmaxmin( R.x1, R.x2, R.y1, R.y2, 0 );
  }
  E.package.texts(T) {
    T.wires(W) {
      if (W.layer == 1 || W.layer == 16 || W.layer == 21 ||  W.layer == 22 ||  W.layer == 51 ||  W.layer == 52 ) {
        if (W.arc) {
          checkarc(W.arc.x1, W.arc.x2, W.arc.y1, W.arc.y2, W.arc.xc, W.arc.yc, W.arc.angle1, W.arc.angle2, W.arc.radius, W.width);
        }
        else  checkmaxmin( W.x1, W.x2, W.y1, W.y2, W.width );
      }
    }
  }
  int mx = maxX -  minX;
  int my = maxY -  minY;
  return u2u(mx) * u2u(my);
}


// main
if (board) {
  board(B) {
    brdfile = B.name;
    int n;
    string usedLayers;
    string displayUnrouted;
    status("Layer");
    B.layers(L) {
      string sl;
      sprintf(sl, "%3d\t%s\t%d", L.number, L.name, L.used);
      allLayers[cntalllay] = sl;
      cntalllay++;
      string Lnam = L.name;
      if (Lnam[0] == '$') {
        SupplyLayers[L.number] = 1; // 2009-07-15 check polygon on supply layer
        SupplyLayerName[L.number] = L.name;
      }
      if (L.used && L.number >=1 && L.number <= 16) {
        cntLayer++;
        sprintf(sl, "%2d %s\n", L.number, L.name);
        usedLayers += sl;
        if (L.number == 1 || L.number == 16) {
          sl = L.name;
          if (sl[0] == '$') {
            sprintf( sl, "Do not use Layer %.d %s for Powerplane! '$' in Layer Name.", L.number, L.name);
            layerError += "\n" + sl;
            sprintf( sl, "<br>Do not use Layer <font color=red>%.d %s</font> for Powerplane!", L.number, L.name);
            displayLayerError += sl;
          }
        }
      }
    }
    if (layerError) {
      layerError += "\n\nUse only inner layer (2 to 15) for Powerplane!\n";
      displayLayerError = "<nobr>" + displayLayerError + "</font><br>" +
                          "<br>Only use layer <font color=blue>2 - 15</font> for power planes.</nobr>";
      dlgMessageBox(displayLayerError, "Ok");
    }
    sprintf(usedLayer, "used layers %d\n\n%s", cntLayer, usedLayers);

    status("Elements");
    B.elements(E) {
      // calculate over xPlace/xDocu/PAD/SMD  12.05.2005 alf@cadsoft.de
      if (E.locked) cntLocked++;
      cntElement++;
      Ename[cntElement] = E.name;
      ELocked[cntElement] = E.locked;
      eUsedLayer[cntElement] = E.mirror;
      eUsedArea[cntElement] = used_area(E); // berechne für jedes Element(Package) den benötigten Platz
      summary_area += eUsedArea[cntElement];
      int cont = 0; // 2009-12-02 package with or without contacts
      E.package.contacts(C) {
        if (C.pad)       list_pac_drills(C.pad.drill);
        cont = 1;
      }
      if (cont) {
        EContact[cntCont] = E.name;
        cntCont++;
      }
      else {
        sprintf(EnoContact[cntNoCont], "%s\t%s", E.name, E.package.name);
        cntNoCont++;
      }
    }

    resetMaxMin();
    status("Wires");
    B.wires(W) {
      if (W.layer == 20) {
        if (W.arc) {
          outlines += ArcLength(W.arc.angle1, W.arc.angle2, u2u(W.arc.radius));
          checkarc(W.arc.x1, W.arc.x2, W.arc.y1, W.arc.y2, W.arc.xc, W.arc.yc, W.arc.angle1, W.arc.angle2, W.arc.radius, W.width);
        }
        else {
          outlines += WireLength(W.x1, W.x2, W.y1, W.y2);
          checkmaxmin( W.x1, W.x2, W.y1, W.y2, W.width );
        }
      }
    }
    status("Circles");
    B.circles(C) {
      if (C.layer == 20) {
        outlines += WireLengthCircle(C.radius);
        checkmaxmin( C.x - C.radius, C.x + C.radius, C.y - C.radius, C.y + C.radius, C.width );
      }
    }
    B.elements(E) {
      status("Element:"+E.name);

/* zombie
      if (E.name == "U$1") {
        string hh;
        sprintf(hh, "%s = %s : %.4f %.4f", E.name, E.value, u2u(E.x), u2u(E.y) );
        if (dlgMessageBox(hh, "OK", "Cancel") != 0) exit(-999);
      }
zombie */

      E.package.wires(W) {
        if (W.layer == 20) {
          // *** Dimension in Packages ***
          outlines += WireLength(W.x1, W.x2, W.y1, W.y2);
          checkmaxmin( W.x1, W.x2, W.y1, W.y2, W.width );
        }
      }
      E.package.circles(C) {
        if (C.layer == 20) {
          outlines += WireLengthCircle(C.radius);
          checkmaxmin( C.x - C.radius, C.x + C.radius, C.y - C.radius, C.y + C.radius, C.width );
        }
        if (C.layer == 29) lSTOPpac[0]++;  // count rect in Stop-Layer 2006-04-28
        if (C.layer == 30) lSTOPpac[1]++;
        if (C.layer == 31) lCREAMpac[0]++;  // count rect in Cream-Layer
        if (C.layer == 32) lCREAMpac[1]++;
      }
      E.package.polygons(P) {
        if (!P.width) PolyWidthError = 1;
        P.wires(W) {
          if (W.width < 10) {
            sprintf(PolygonLayer[cPolygonL], "Package\t%s.PAC \t%d\t%d\t%.4f", E.package.name, W.layer, P.rank, u2mm(P.width));
            cPolygonL++;
          }
          break;
        }
        if (P.layer == 29) lSTOPpac[0]++;  // count rect in Stop-Layer 2006-04-28
        if (P.layer == 30) lSTOPpac[1]++;
        if (P.layer == 31) lCREAMpac[0]++;  // count rect in Cream-Layer
        if (P.layer == 32) lCREAMpac[1]++;
      }
      E.package.rectangles(R) {
        if (R.layer == 29) lSTOPpac[0]++;  // count rect in Stop-Layer 2006-04-28
        if (R.layer == 30) lSTOPpac[1]++;
        if (R.layer == 31) lCREAMpac[0]++;  // count rect in Cream-Layer
        if (R.layer == 32) lCREAMpac[1]++;
      }
    }

    if (outlines) {
       sprintf(brdoutline, "Outline contour = %.2f", outlines);
       sprintf(brdmaximum, "max. Board length (Layer 20)\nX = %.2f\nY = %.2f",  WireLength(minX, maxX, 0,0), WireLength(minY, maxY, 0, 0) );
    }

    B.classes(CL) {
      // Net classes ********************
      NetClassNr[CL.number] = CL.number;
      NetClassName[CL.number] = CL.name;
      NetClassWidth[CL.number] = CL.width;
      NetClassClear[CL.number] = CL.clearance;
      NetClassDrill[CL.number] = CL.drill;
      cNetClass[CL.number] = 0;
    }
    B.signals(S) {
      status("Signal:"+S.name);
      int true = 0;      // only signal if connected to pad or smd is a true signal 2005-12-08 alf@cadsoft.de
      S.contactrefs(C) {
        true = 1;
        break;
      }
      if (true) {
        cNetClass[S.class.number]++;
        sumSignals++;
        SignalName[SignalCnt]  = S.name;
        SignalClass[SignalCnt] = S.class.number;
        SignalCnt++;
        SignalClassList[S.class.number] += S.name + "\n";
      }
      else {
        S.vias(V) {
          cntfalseSignalVias[falseSignalCnt]++;
          sprintf(FalsWxy[falseSignalCnt], "(%.4f %.4f) L %d-%d", u2mm(V.x), u2mm(V.y), V.start, V.end);

        }
        S.wires(W) {
          cntfalseSignalWires[falseSignalCnt]++;
          sprintf(FalsWxy[falseSignalCnt], "(%.4f %.4f) L %d", u2mm(W.x1), u2mm(W.y1), W.layer);
        }
        if (cntfalseSignalWires[falseSignalCnt] || cntfalseSignalVias[falseSignalCnt]) {  // 2009-02-12
          falseSignalList[falseSignalCnt] = S.name;  // only signal if connected to pad or smd is a true signal
          falseSignalCnt++;
        }
        else {
          string s;
          sprintf(s, "WIRE '%s' (%.4f %.4f) (%.4f %.4f);DELETE (%.4f %.4f);\n",
                        S.name,
                        u2mm(B.area.x1)-1.0, u2mm(B.area.y1)-1.0,
                        u2mm(B.area.x1)-2.0, u2mm(B.area.y1)-1.0,
                        u2mm(B.area.x1)-1.0, u2mm(B.area.y1)-1.0
                 );
          deleteRudimentalSignalName+=s;
        }
      }

      // Wires ********************
      S.wires(W) {
        if (W.layer < 19) {
          if (W.arc) {
            for (int n = 0; n <= cntArc; n++) {
              if (ArcWidth[n] == W.arc.width) {
                cArcWidth[n]++;
                break;
              }
            }
            if (n > cntArc) {
              cntArc++;
              ArcWidth[cntArc] = W.arc.width;
              cArcWidth[cntArc]++;
            }
          }
          else {
            for (n = 0; n <= cntWire; n++) {
              if (WireWidth[n] == W.width) {
                cWireWidth[n]++;
                break;
              }
            }
            if (n > cntWire) {
              cntWire++;
              WireWidth[cntWire] = W.width;
              cWireWidth[cntWire]++;
            }
          }
        }
        else {
          SignalUnrouted++;
        }
      }

      // Polygone *********************
      S.polygons(P) {
        // Polygon Wire width *********
        if (SupplyLayers[P.layer]) {
          SupplyLayersUsedPolygons[P.layer]++;
        }
        if (!P.width) PolyWidthError = 1;
        P.wires(W) {
          sprintf(PolygonLayer[cPolygonL], "Signal\t%s\t%d\t%d\t%.3f", S.name, P.layer, P.rank, u2mm(W.width) );
                                           // Polygon Rank 19.07.2005 alf
          cPolygonL++;
          break;
        }
        for (n = 0; n <= cntPolyW; n++) {
          if (PolygonWidth[n] == P.width) {
            cPolygonWidth[n]++;
            break;
          }
        }
        if (n > cntPolyW) {
          cntPolyW++;
          PolygonWidth[cntPolyW] = P.width;
          cPolygonWidth[cntPolyW]++;
        }
        // Polygon isolate *********
        for (n = 0; n <= cntPolyIso; n++) {
          if (PolygonIsolate[n] == P.isolate) {
            cPolygonIsolate[n]++;
            break;
          }
        }
        if (n > cntPolyIso) {
          cntPolyIso++;
          PolygonIsolate[cntPolyIso] = P.isolate;
          cPolygonIsolate[cntPolyIso]++;
        }
      }

      // Vias *********************
      S.vias(V) {
        // Vias Drill *********************
        for (int n = 0; n <= cntVDril; n++) {
          if (ViaDrill[n] == V.drill) {
          cViaDrill[n]++;
          break;
        }
      }
      if (n > cntVDril) {
        cntVDril++;
        ViaDrill[cntVDril] = V.drill;
        cViaDrill[cntVDril]++;
      }

      // Vias Diameter TOP *********************
      for (n = 0; n <= cntVDiam; n++) {
        if (ViaDiameter[n] == V.diameter[LAYER_BOTTOM]) {
          cViaDiameter[n]++;
          break;
        }
      }
      if (n > cntVDiam) {
        cntVDiam++;
        ViaDiameter[cntVDiam] = V.diameter[LAYER_BOTTOM];
        cViaDiameter[cntVDiam]++;
      }

      // Vias Diameter Inner Layer *********************
      for (n = 0; n <= cntVDiamI; n++) {
        if (ViaDiameterI[n] == V.diameter[2]) {
          cViaDiameterI[n]++;
          break;
        }
      }
      if (n > cntVDiamI) {
        cntVDiamI++;
        ViaDiameterI[cntVDiamI] = V.diameter[2];
        cViaDiameterI[cntVDiamI]++;
      }

      // Vias Restring Top Bottom *********************
      int VRestringO = (V.diameter[LAYER_BOTTOM] - V.drill ) / 2;
      for (n = 0; n <= cntVringO; n++) {
        if (ViaRestringO[n] == VRestringO) {
          cViaRestringO[n]++;
          break;
        }
      }
      if (n > cntVringO) {
        cntVringO++;
        ViaRestringO[cntVringO] = VRestringO;
        cViaRestringO[cntVringO]++;
      }
      // Vias Restring Inner Layer *********************
      int VRestringI = (V.diameter[2] - V.drill ) / 2;
      for (n = 0; n <= cntVringI; n++) {
        if (ViaRestringI[n] == VRestringI) {
          cViaRestringI[n]++;
          break;
        }
      }
      if (n > cntVringI) {
        cntVringI++;
        ViaRestringI[cntVringI] = VRestringI;
        cViaRestringI[cntVringI]++;
      }
      viaStackRack(V.start, V.end, u2mm(V.drill));
    }
    S.contactrefs(C) {
      cnt_pad_on_signal++;
    }
  }

  B.holes(H) {
    // Holes Board *********************
    for (int n = 0; n <= cntHole; n++) {
      if (Hole[n] == H.drill) {
        cHole[n]++;
        break;
      }
    }
    if (n > cntHole) {
      cntHole++;
      Hole[cntHole] = H.drill;
      cHole[cntHole]++;
    }
  }
  B.circles(C) {
    if (C.layer < 19) {
      for (int n = 0; n <= cntCircl; n++) {
        if (CirclWidth[n] == C.width) {
          cCirclWidth[n]++;
          break;
        }
      }
      if (n > cntCircl ) {
        cntCircl++;
        CirclWidth[cntCircl] = C.width;
        cCirclWidth[cntCircl]++;
      }
      for (n = 0; n <= cntCirclDiam; n++) {
        if (CirclDiam[n] == C.radius*2) {
          cCirclDiam[n]++;
          break;
        }
      }
      if (n > cntCirclDiam ) {
        cntCirclDiam++;
        CirclDiam[cntCircl] = C.radius*2;
        cCirclDiam[cntCirclDiam]++;
      }
    }
    if (C.layer == 29) lSTOPbrd[0]++;  // count circle in Stop-Layer 2006-04-28
    if (C.layer == 30) lSTOPbrd[1]++;
    if (C.layer == 31) lCREAMbrd[0]++;  // count circle in Cream-Layer
    if (C.layer == 32) lCREAMbrd[1]++;
  }

  B.rectangles(R) {
    if (R.layer < 19) {
      int r_x = R.x2 - R.x1;
      int r_y = R.y2 - R.y1;
      for (int n = 0; n <= cntRECT; n++) {
        if ( RECTx[n] == r_x && RECTy[n] == r_y ) {
          cRECT[n]++;
          break;
        }
      }
      if (n > cntRECT ) {
        cntRECT++;
        RECTx[cntRECT] = r_x;
        RECTy[cntRECT] = r_y;
        cRECT[cntRECT]++;
      }
    }
    if (R.layer == 29) lSTOPbrd[0]++;  // count rect in Stop-Layer 2006-04-28
    if (R.layer == 30) lSTOPbrd[1]++;
    if (R.layer == 31) lCREAMbrd[0]++;  // count rect in Cream-Layer
    if (R.layer == 32) lCREAMbrd[1]++;
  }
  status("Text");
  B.texts(T) {
    if (T.layer < 19) {
      for (int n = 0; n <= cntTextSize; n++) {
        if (TextSize[n] == T.size) {
          cTextSize[n]++;
          break;
        }
      }
      if (n > cntTextSize) {
        cntTextSize++;
        TextSize[cntTextSize] = T.size;
        cTextSize[cntTextSize]++;
      }
      T.wires(W) {
        for (int n = 0; n <= cntTextWidth; n++) {
          if (TextWidth[n] == W.width) {
            cTextWidth[n]++;
            break;
          }
        }
        if (n > cntTextWidth) {
          cntTextWidth++;
          TextWidth[cntTextWidth] = W.width;
          cTextWidth[cntTextWidth]++;
        }
        break;
      }
    }
    if (T.layer >= 21 && T.layer <= 27) {
      for (int n = 0; n <= cntPlaceTextSize; n++) {
        if (PlaceTextSize[n] == T.size) {
          cPlaceTextSize[n]++;
          break;
        }
      }
      if (n > cntPlaceTextSize) {
        cntPlaceTextSize++;
        PlaceTextSize[cntPlaceTextSize] = T.size;
        cPlaceTextSize[cntPlaceTextSize]++;
      }
      T.wires(W) {
        for (int n = 0; n <= cntPlaceTextWidth; n++) {
          if (PlaceTextWidth[n] == W.width) {
            cPlaceTextWidth[n]++;
            break;
          }
        }
        if (n > cntPlaceTextWidth) {
          cntPlaceTextWidth++;
          PlaceTextWidth[cntPlaceTextWidth] = W.width;
          cPlaceTextWidth[cntPlaceTextWidth]++;
        }
        break;
      }
    }
  }

  B.polygons(P) {
    if (P.layer == 29) lSTOPbrd[0]++;  // count polygon in Stop-Layer 2006-04-28
    if (P.layer == 30) lSTOPbrd[1]++;
    if (P.layer == 31) lCREAMbrd[0]++;  // count polygon in Cream-Layer
    if (P.layer == 32) lCREAMbrd[1]++;
  }

  B.elements(E) {
    status("Package:"+E.package.name);
    E.package.holes(H) {
      // Holes Board *********************
      for (int n = 0; n <= cntHole; n++) {
        if (Hole[n] == H.drill) {
          cHole[n]++;
          break;
        }
      }
      if (n > cntHole) {
        cntHole++;
        Hole[cntHole] = H.drill;
        cHole[cntHole]++;
      }
    }

    E.package.contacts(C) {
      if (C.smd) {
        if (C.smd.layer == LAYER_TOP) cntSMDt++;
        else cntSMDb++;
        for (int n = 0; n <= cntSMD; n++) {
          if ( (SMDx[n] == C.smd.dx && SMDy[n] == C.smd.dy) ) {
            cSMD[n]++;
            break;
          }
        }
        if (n > cntSMD) {
          cntSMD++;
          SMDx[cntSMD] = C.smd.dx;
          SMDy[cntSMD] = C.smd.dy;
          cSMD[cntSMD]++;
        }
      }

      if (C.pad) {
        // Drills
        viaStackRack(1, 16, u2mm(C.pad.drill));    // 2009-10-15 pads use also in layer rack
        for ( n = 0; n <= cntPDril; n++) {
          if (PadDrill[n] == C.pad.drill) {
            cPadDrill[n]++;
            break;
          }
        }
        if (n > cntPDril) {           // a new drill
          cntPDril++;
          PadDrill[cntPDril] = C.pad.drill;
          cPadDrill[cntPDril]++;
        }
        // Bottom layer
        for ( n = 0; n <= cntPDiamBOT; n++) {
          if (PadDiameterBOT[n] == C.pad.diameter[LAYER_BOTTOM]) {
            cPadDiameterBOT[n]++;
            break;
          }
        }
        if (n > cntPDiamBOT) {
          cntPDiamBOT++;
          PadDiameterBOT[cntPDiamBOT] = C.pad.diameter[LAYER_BOTTOM];
          cPadDiameterBOT[cntPDiamBOT]++;
        }
        // Top layer
        for (n = 0; n <= cntPDiamTOP; n++) {
          if (PadDiameterTOP[n] == C.pad.diameter[LAYER_TOP]) {
            cPadDiameterTOP[n]++;
            break;
          }
        }
        if (n > cntPDiamTOP) {
          cntPDiamTOP++;
          PadDiameterTOP[cntPDiamTOP] = C.pad.diameter[LAYER_TOP];
          cPadDiameterTOP[cntPDiamTOP]++;
        }
        // Inner layer
        for ( n = 0; n <= cntiPDiam; n++) {
          if (iPadDiameter[n] == C.pad.diameter[2]) {
            ciPadDiameter[n]++;
            break;
          }
        }
        if (n > cntiPDiam) {
          cntiPDiam++;
          iPadDiameter[cntiPDiam] = C.pad.diameter[2];
          ciPadDiameter[cntiPDiam]++;
        }
        // Top-Restring *************************
        int Trestring = (C.pad.diameter[LAYER_TOP] - C.pad.drill) / 2;
        for ( n = 0; n <= cntPringTOP; n++) {
          if (PadRestringTOP[n] == Trestring) {
            cPadRestringTOP[n]++;
            break;
          }
        }
        if (n > cntPringTOP) {
          cntPringTOP++;
          PadRestringTOP[cntPringTOP] = Trestring;
         cPadRestringTOP[cntPringTOP]++;
        }

        // Bottom-Restring *************************
        int Brestring = (C.pad.diameter[LAYER_BOTTOM] - C.pad.drill) / 2;
        for ( n = 0; n <= cntPringBOT; n++) {
          if (PadRestringBOT[n] == Brestring) {
            cPadRestringBOT[n]++;
            break;
          }
        }
        if (n > cntPringBOT) {
          cntPringBOT++;
          PadRestringBOT[cntPringBOT] = Brestring;
          cPadRestringBOT[cntPringBOT]++;
        }

        // Inner-Restring *************************
        int Irestring = (C.pad.diameter[2] - C.pad.drill) / 2;
        for ( n = 0; n <= cntPringI; n++) {
          if (PadRestringI[n] == Irestring) {
            cPadRestringI[n]++;
            break;
          }
        }
        if (n > cntPringI) {
          cntPringI++;
          PadRestringI[cntPringI] = Irestring;
          cPadRestringI[cntPringI]++;
        }
        int schape    = C.pad.shape[LAYER_TOP];
        schape    = C.pad.shape[LAYER_BOTTOM];
        schape    = C.pad.shape[2];
      }
    }
    // Texte in Package [copper]
    E.package.texts(T) {
      if (T.layer < 19) {
        T.wires(W) {
          for (int n = 0; n <= cntTextWidth; n++) {
            if (TextWidth[n] == W.width) {
              cTextWidth[n]++;
              break;
            }
          }
          if (n > cntTextWidth) {
            cntTextWidth++;
            TextWidth[cntTextWidth] = W.width;
            cTextWidth[cntTextWidth]++;
          }
          break;
        }
      }
      if (T.layer >= 21 && T.layer <= 27) {
        for (int n = 0; n <= cntPlaceTextSize; n++) {
          if (PlaceTextSize[n] == T.size) {
            cPlaceTextSize[n]++;
            break;
          }
        }
        if (n > cntPlaceTextSize) {
          cntPlaceTextSize++;
          PlaceTextSize[cntPlaceTextSize] = T.size;
          cPlaceTextSize[cntPlaceTextSize]++;
        }
        T.wires(W) {
          for (int n = 0; n <= cntPlaceTextWidth; n++) {
            if (PlaceTextWidth[n] == W.width) {
              cPlaceTextWidth[n]++;
              break;
            }
          }
          if (n > cntPlaceTextWidth) {
            cntPlaceTextWidth++;
            PlaceTextWidth[cntPlaceTextWidth] = W.width;
            cPlaceTextWidth[cntPlaceTextWidth]++;
          }
          break;
        }
      }
    }

    // Wires in Package [copper]
    E.package.wires(W) {
      if (W.layer < 19) {
        for (n = 0; n <= cntWire; n++) {
          if (WireWidth[n] == W.width) {
            cWireWidth[n]++;
            break;
          }
        }
        if (n > cntWire) {
          cntWire++;
          WireWidth[cntWire] = W.width;
          cWireWidth[cntWire]++;
        }
      }
    }

    // Polygon wires in Package [copper]
    E.package.polygons(P) {
      if (P.layer < 19) {
        for (n = 0; n <= cntPolyW; n++) {
          if (PolygonWidth[n] == P.width) {
            cPolygonWidth[n]++;
            break;
          }
        }
        if (n > cntPolyW) {
          cntPolyW++;
          PolygonWidth[cntPolyW] = P.width;
          cPolygonWidth[cntPolyW]++;
        }
        // Polygon isolate *********
        for (n = 0; n <= cntPolyIso; n++) {
          if (PolygonIsolate[n] == P.isolate) {
            cPolygonIsolate[n]++;
            break;
          }
        }
        if (n > cntPolyIso) {
          cntPolyIso++;
          PolygonIsolate[cntPolyIso] = P.isolate;
          cPolygonIsolate[cntPolyIso]++;
        }
      }
    }

    // Rectangles in Package [copper]
    E.package.rectangles(R) {
      if (R.layer < 19) {
        int r_x = R.x2 - R.x1;
        int r_y = R.y2 - R.y1;
        for (int n = 0; n <= cntRECT; n++) {
          if ( RECTx[n] == r_x && RECTy[n] == r_y ) {
            cRECT[n]++;
            break;
          }
        }
        if (n > cntRECT ) {
          cntRECT++;
          RECTx[cntRECT] = r_x;
          RECTy[cntRECT] = r_y;
          cRECT[cntRECT]++;
        }
      }
    }

    // Circles in Package [copper]
    E.package.circles(C) {
      if (C.layer < 19) {
        for (int n = 0; n <= cntCircl; n++) {
          if (CirclWidth[n] == C.width) {
            cCirclWidth[n]++;
            break;
          }
        }
        if (n > cntCircl ) {
          cntCircl++;
          CirclWidth[cntCircl] = C.width;
          cCirclWidth[cntCircl]++;
        }
        for (n = 0; n <= cntCirclDiam; n++) {
          if (CirclDiam[n] == C.radius*2) {
            cCirclDiam[n]++;
            break;
          }
        }
        if (n > cntCirclDiam ) {
          cntCirclDiam++;
          CirclDiam[cntCircl] = C.radius*2;
          cCirclDiam[cntCirclDiam]++;
        }
      }
      if (C.layer == 29) lSTOPbrd[0]++;  // count circle in Stop-Layer 2006-04-28
      if (C.layer == 30) lSTOPbrd[1]++;
      if (C.layer == 31) lCREAMbrd[0]++;  // count circle in Cream-Layer
      if (C.layer == 32) lCREAMbrd[1]++;
    }

    // Masks in in Package
    E.package.contacts(C) {
      if (C.pad) {
        if (C.pad.flags && PAD_FLAG_STOP) {
          padlSTOP[0]++;  // top
          padlSTOP[1]++;  // bottom
        }
      }
      if (C.smd) {
        if (C.smd.flags && SMD_FLAG_STOP)  smdlSTOP[E.mirror]++;
        if (C.smd.flags && SMD_FLAG_CREAM) smdlCREAM[E.mirror]++;
      }
    }

    // Element Libraries *********
    for (n = 0; n <= cntLbr; n++) {
      if (Lbr[n] == E.package.library) {
        cLbr[n]++;
        break;
      }
    }
    if (n > cntLbr) {
      cntLbr++;
      Lbr[cntLbr] = E.package.library;
      cLbr[cntLbr]++;
    }
    // Element Package *********
    for (n = 0; n <= cntPacName; n++) {
      if (PacName[n] == E.package.name) {
        cPacName[n]++;
        break;
      }
    }
    if (n > cntPacName) {
      cntPacName++;
      PacName[cntPacName] = E.package.name;
      cPacName[cntPacName]++;
    }

    // Element Value ********* 2005-12-01 alf@cadsoft.de
/*
    // -------- List by Value ------------
    for (n = 0; n <= cntEValue; n++) {
      if (EValue[n] == Ev) {
        cEValue[n]++;
        break;
      }
    }
    if (n > cntEValue) {
      cntEValue++;
      EValue[cntEValue] = Ev;
      cEValue[cntEValue]++;
    }
*/
    // ----- List by Value/Package/Layer -----------
    string Ev = E.value;
    if (Ev == "") {
      Ev = empty + E.name;
      emptyValue++;
    }
    for (n = 0; n <= cntEVPL; n++) {
      if (EVALpac[n] == Ev && EvalPAC[n] == E.package.name ) {
        cEVPL[n]++;
        if (E.mirror)  cEVPL16[n]++;
        else  cEVPL1[n]++;
        break;
      }
    }
    if (n > cntEVPL) {
      cntEVPL++;
      EVALpac[cntEVPL] = Ev;
      EvalPAC[cntEVPL] = E.package.name;
      cEVPL[cntEVPL]++;
      if (E.mirror)  cEVPL16[cntEVPL]++;
      else  cEVPL1[cntEVPL]++;
    }
  }
  status("creat list");

  if (PolyWidthError) PolygonError = "! *** Do not use WIRE WIDTH 0 for Polygon if generate Gerber-Data *** !";
  int x = 0;
  // Statistic tabels
  // Net Class ********************
  statisticCLASS[x] = "# \tName\tmin. Width\tClearance\tmin. Drill\tUsed";
  for (n = 0; n < 8; n++) {
    if (NetClassName[n]) {
      if(minClearance > NetClassClear[n]) minClearance = NetClassClear[n];
      x++;
      sprintf(statisticCLASS[x], "%1d\t%s\t%s\t%s\t%s\t%-4d",
                  NetClassNr[n],
                  NetClassName[n],
                  value(NetClassWidth[n], ""),
                  value(NetClassClear[n], ""),
                  value(NetClassDrill[n], ""),
                  cNetClass[n]
             );
      selNetClassNr[x] = NetClassNr[n];
    }
  }

  x = 0;
  // false Signals ******************** 2005-12-08 alf@cadsoft.de
  statisticFalseSignals[x] = "Signal-Name\tVias\tCoordinate Layer";
  for (n = 0; n < falseSignalCnt; n++) {
    x++;
    sprintf( statisticFalseSignals[x], "%s\t%d\t%s",
                    falseSignalList[n],  // only signal if connected to pad or smd is a true signal 2005-12-08 alf@cadsoft.de
                    cntfalseSignalVias[n],
                    FalsWxy[n]
           );
  }

    // ************* Wire statistic *****************
    x = 0;
    statisticWirew[x] = "WIRE\tQ.";
    for (n = 0; n <= cntWire; n++) {
      if (cWireWidth[n]) {
        sumWires += cWireWidth[n];
        if(minWires > WireWidth[n]) minWires = WireWidth[n];
        x++;
        sprintf(statisticWirew[x], "%s\t%-4d", value(WireWidth[n], ""), cWireWidth[n] );
      }
    }

    x = 0;
    statisticARCw[x] = "ARC\tQ.";
    for ( n = 0; n <= cntArc; n++) {
      if (cArcWidth[n]) {
        sumARCw += cArcWidth[n];
        if(minARCw > ArcWidth[n]) minARCw = ArcWidth[n];
        x++;
        sprintf(statisticARCw[x], "%s\t%-4d", value(ArcWidth[n], ""), cArcWidth[n] );
      }
    }

    x = 0;
    statisticCIRw[x] = "CIRCLE (width)\tQ.";
    for ( n = 0; n <= cntCircl; n++) {
      if (cCirclWidth[n]) {
        sumCIRCw += cCirclWidth[n];
        if(minCIRCw > CirclWidth[n]) minCIRCw = CirclWidth[n];
        x++;
        sprintf(statisticCIRw[x], "%s\t%-4d", value(CirclWidth[n], ""), cCirclWidth[n] );
      }
    }

    x = 0;
    statisticCIRdiam[x] = "CIRCLE diam.\tQ.";
    for ( n = 0; n <= cntCirclDiam; n++) {
      if (cCirclDiam[n]) {
        sumCIRCdiam += cCirclDiam[n];
        if(minCIRCdiam > CirclDiam[n]) minCIRCdiam = CirclDiam[n];
        x++;
        sprintf(statisticCIRdiam[x], "%s\t%-4d", value(CirclDiam[n], ""), cCirclDiam[n] );
      }
    }

    x = 0;
    statisticPolyw[x] = "POLY. width\tQ.";
    for ( n = 0; n <= cntPolyW; n++) {
      if (cPolygonWidth[n]) {
        sumPOLYw += cPolygonWidth[n];
        if(minPOLYw > PolygonWidth[n]) minPOLYw = PolygonWidth[n];
        x++;
        sprintf(statisticPolyw[x], "%s\t%-4d", value(PolygonWidth[n], ""), cPolygonWidth[n]);
        // ATTENTION : Width saved in .2 Micron
      }
    }

    x = 0;
    statisticPoliso[x] = "POLY. Isol.\tQ.";
    for ( n = 0; n <= cntPolyIso; n++) {
      if (cPolygonIsolate[n]) {
        sumISOL += cPolygonIsolate[n];
        if(minISOL > PolygonIsolate[n]) minISOL = PolygonIsolate[n];
        x++;
        sprintf(statisticPoliso[x], "%s\t%-4d", value(PolygonIsolate[n], ""), cPolygonIsolate[n]);
      }
    }

    x = 0;
    statisticRECT[x] = "RECT x\tRECT y\tQ.";
    for ( n = 0; n <= cntRECT; n++) {
      if (cRECT[n]) {
        sumRECT += cRECT[n];
        if(minRECTx > RECTx[n]) minRECTx = RECTx[n];
        if(minRECTy > RECTy[n]) minRECTy = RECTy[n];
        x++;
        sprintf(statisticRECT[x], "%s\t%s\t%-4d", value(RECTx[n], ""), value(RECTy[n], ""), cRECT[n]);
      }
    }

    x = 0;
    statisticSMD[x] = "SMD x\tSMD y\tQ.";
    for ( n = 0; n <= cntSMD; n++) {
      if (cSMD[n]) {
        sumSMD += cSMD[n];
        if(minSMDx > SMDx[n]) minSMDx = SMDx[n];
        if(minSMDy > SMDy[n]) minSMDy = SMDy[n];
        x++;
        sprintf(statisticSMD[x], "%s\t%s\t%-4d", value(SMDx[n], ""), value(SMDy[n], ""), cSMD[n]);
      }
    }

    x = 0;
    statisticPADdril[x] = "PAD drill\tQ.";
    for (n = 0; n <= cntPDril; n++) {
      if (cPadDrill[n]) {
        sumPADdril += cPadDrill[n];
        if(minPADdril > PadDrill[n]) minPADdril = PadDrill[n];
        x++;
        sprintf(statisticPADdril[x], "%s\t%-4d", value(PadDrill[n], ""), cPadDrill[n]);
      }
    }

    x = 0;
    statisticPADdiaTOP[x] = "PAD tDiam\tQ.";
    for ( n = 0; n <= cntPDiamTOP; n++) {
      if (cPadDiameterTOP[n]) {
        sumPADdia += cPadDiameterTOP[n];
        if(minPADdia > PadDiameterTOP[n]) minPADdia = PadDiameterTOP[n];
        x++;
        sprintf(statisticPADdiaTOP[x], "%s\t%-4d", value(PadDiameterTOP[n], ""), cPadDiameterTOP[n]);
      }
    }

    x = 0;
    statisticPADdiaBOT[x] = "PAD bDiam\tQ.";
    for ( n = 0; n <= cntPDiamBOT; n++) {
      if (cPadDiameterBOT[n]) {
        sumPADdia += cPadDiameterBOT[n];
        if(minPADdia > PadDiameterBOT[n]) minPADdia = PadDiameterBOT[n];
        x++;
        sprintf(statisticPADdiaBOT[x], "%s\t%-4d", value(PadDiameterBOT[n], ""), cPadDiameterBOT[n]);
      }
    }

    x = 0;
    statisticPADdiaI[x] = "PAD iDiam\tQ.";
    for ( n = 0; n <= cntiPDiam; n++) {
      if (ciPadDiameter[n]) {
        sumPADdiaI += ciPadDiameter[n];
        if(minPADdiaI > iPadDiameter[n]) minPADdiaI = iPadDiameter[n];
        x++;
        sprintf(statisticPADdiaI[x], "%s\t%-4d", value(iPadDiameter[n], ""), ciPadDiameter[n]);
      }
    }

    x = 0;
    statisticPADrestTOP[x] = "PAD tRestring\tQ.";
    for ( n = 0; n <= cntPringTOP; n++) {
      if (cPadRestringTOP[n]) {
        sumPADrest += cPadRestringTOP[n];
        if(minPADrest > PadRestringTOP[n]) minPADrest = PadRestringTOP[n];
        x++;
        sprintf(statisticPADrestTOP[x], "%s\t%-4d", value(PadRestringTOP[n], ""), cPadRestringTOP[n]);
      }
    }

    x = 0;
    statisticPADrestBOT[x] = "PAD bRestring\tQ.";
    for ( n = 0; n <= cntPringBOT; n++) {
      if (cPadRestringBOT[n]) {
        sumPADrest += cPadRestringBOT[n];
        if(minPADrest > PadRestringBOT[n]) minPADrest = PadRestringBOT[n];
        x++;
        sprintf(statisticPADrestBOT[x], "%s\t%-4d", value(PadRestringBOT[n], ""), cPadRestringBOT[n]);
      }
    }

    x = 0;
    statisticPADrestI[x] = "PAD iRestring\tQ.";
    for ( n = 0; n <= cntPringI; n++) {
      if (cPadRestringI[n]) {
        sumPADrestI += cPadRestringI[n];
        if(minPADrestI > PadRestringI[n]) minPADrestI = PadRestringI[n];
        x++;
        sprintf(statisticPADrestI[x], "%s\t%-4d", value(PadRestringI[n], ""), cPadRestringI[n]);
      }
    }

    x = 0;
    statisticVIAdril[x] = "VIA drill\tQ.";
    for ( n = 0; n <= cntVDril; n++) {
      if (cViaDrill[n]) {
        sumVIAdril += cViaDrill[n];
        if(minVIAdril > ViaDrill[n]) minVIAdril = ViaDrill[n];
        x++;
        sprintf(statisticVIAdril[x], "%s\t%-4d", value(ViaDrill[n], ""), cViaDrill[n] );
      }
    }

    x = 0;
    statisticVIAdia[x] = "VIA Outer-Diam\tQ.";
    for ( n = 0; n <= cntVDiam; n++) {
      if (cViaDiameter[n]) {
        sumVIAdiam += cViaDiameter[n];
        if(minVIAdiam > ViaDiameter[n]) minVIAdiam = ViaDiameter[n];
        x++;
        sprintf(statisticVIAdia[x], "%s\t%-4d", value(ViaDiameter[n], ""), cViaDiameter[n] );
      }
    }

    x = 0;
    statisticVIAdiaI[x] = "VIA Inner-Diam.\tQ.";
    for ( n = 0; n <= cntVDiamI; n++) {
      if (cViaDiameterI[n]) {
        sumVIAdiamI += cViaDiameterI[n];
        if(minVIAdiamI > ViaDiameterI[n]) minVIAdiamI = ViaDiameterI[n];
        x++;
        sprintf(statisticVIAdiaI[x], "%s\t%-4d", value(ViaDiameterI[n], ""), cViaDiameterI[n] );
      }
    }

    x = 0;
    statisticVIArest[x] = "VIA Outer-Restring \tQ.";
    for ( n = 0; n <= cntVringO; n++) {
      if (cViaRestringO[n]) {
        sumVIArest += cViaRestringO[n];
        if(minVIArest > ViaRestringO[n]) minVIArest = ViaRestringO[n];
        x++;
        sprintf(statisticVIArest[x], "%s\t%-4d", value(ViaRestringO[n], ""), cViaRestringO[n]);
      }
    }

    x = 0;
    statisticVIArestI[x] = "VIA Inner-Restring\tQ.";
    for ( n = 0; n <= cntVringI; n++) {
      if (cViaRestringI[n]) {
        sumVIArestI += cViaRestringI[n];
        if(minVIArestI > ViaRestringI[n]) minVIArestI = ViaRestringI[n];
        x++;
        sprintf(statisticVIArestI[x], "%s\t%-4d", value(ViaRestringI[n], ""), cViaRestringI[n]);
      }
    }

    x = 0;
    statisticVIAstack[x] = "VIA Stack\tQ.";
    for ( n = 0; n < cntStack; n++) {
      x++;
      sprintf(statisticVIAstack[x], "%s\t%-4d", ViaStack[n], ViaStackCnt[n]);
    }

    x = 0;
    statisticHOLE[x] = "HOLE drill\tQ.";
    for ( n = 0; n <= cntHole; n++) {
      if (cHole[n]) {
        sumHOLE += cHole[n];
        if(minHOLE > Hole[n]) minHOLE = Hole[n];
        x++;
        sprintf(statisticHOLE[x], "%s\t%-4d", value(Hole[n], ""), cHole[n]);
      }
    }

    x = 0;
    statisticTEXTw[x] = "TEXT (w)\tQ.";
    for ( n = 0; n <= cntTextWidth; n++) {
      if (cTextWidth[n]) {
        sumTEXTw += cTextWidth[n];
        if(minTEXTw > TextWidth[n]) minTEXTw = TextWidth[n];
        x++;
        sprintf(statisticTEXTw[x], "%s\t%-4d",  value(TextWidth[n], ""),cTextWidth[n] );
      }
    }

    x = 0;
    statisticTEXTsize[x] = "TEXT (s)\tQ.";
    for ( n = 0; n <= cntTextSize; n++) {
      if (cTextSize[n]) {
        x++;
        sprintf(statisticTEXTsize[x], "%s\t%-4d",  value(TextSize[n], ""),cTextSize[n] );
      }
    }

    x = 0;
    statisticPlaceTEXTw[x] = "TEXT \tQ.";
    for ( n = 0; n <= cntPlaceTextWidth; n++) {
      if (cPlaceTextWidth[n]) {
        sumPlaceTEXTw += cPlaceTextWidth[n];
        if(minPlaceTEXTw > PlaceTextWidth[n]) minPlaceTEXTw = PlaceTextWidth[n];
        x++;
        sprintf(statisticPlaceTEXTw[x], "%s\t%-4d",  value(PlaceTextWidth[n], ""),cPlaceTextWidth[n] );
      }
    }

    x = 0;
    statisticPlaceTEXTsize[x] = "TEXT \tQ.";
    for ( n = 0; n <= cntPlaceTextSize; n++) {
      if (cPlaceTextSize[n]) {
        x++;
        sprintf(statisticPlaceTEXTsize[x], "%s\t%-4d",  value(PlaceTextSize[n], ""),cPlaceTextSize[n] );
      }
    }

    x = 0;
    statisticLBR[x] = "LIBRARY\tQ.";
    for ( n = 0; n <= cntLbr; n++) {
      if (cLbr[n]) {
        x++;
        sprintf(statisticLBR[x], "%s\t%-4d",  Lbr[n], cLbr[n] );
      }
    }

    x = 0;
    statisticPAC[x] = "PACKAGE\tQ.";
    for ( n = 0; n <= cntPacName; n++) {
      if (cPacName[n]) {
        x++;
        sprintf(statisticPAC[x], "%s\t%-4d",  PacName[n], cPacName[n] );
      }
    }

    x = 0;
    statisticValPacLay[x] = "VALUE\tPAC\tQ.\tTop\tBot";
    for ( n = 0; n <= cntEVPL; n++ ) {
      if (cEVPL[n]) {
        x++;
        sprintf(statisticValPacLay[x], "%s\t%s\t%d\t%d\t%d",
                EVALpac[n], EvalPAC[n], cEVPL[n], cEVPL1[n], cEVPL16[n] );
      }
    }
    sprintf(statisticLocked, "%d Elements: <b>%d locked</b> %d unlocked", cntElement, cntLocked, cntElement-cntLocked);

    x = 0;
    // Drill Rack statistic
    status("Drill/Rack");
    B.holes(H) AddDrilling(H.drill);
    B.signals(S) S.vias(V) AddDrilling(V.drill);
    B.elements(E) {
      E.package.contacts(C) {
        if (C.pad)
          AddDrilling(C.pad.drill);
      }
      E.package.holes(H) AddDrilling(H.drill);
    }
    sort(imax, Drilling);

    drillRack[0] = "RACK";
    for (int i = 0; i < imax; ++i) {
      string s;
      sprintf(s, "T%02d %5.*f", i + 1, unitPrec[uval], Drilling[i]);
      drillRack[i + 1] = s;
    }
    status("Unroutet");
    if (SignalUnrouted) {
      sprintf(displayUnrouted, "<nobr>%d &nbsp;&nbsp; <font color=red> unroutet (airwire)</font></nobr>", SignalUnrouted );
      sprintf(Unrouted, "%d", SignalUnrouted);
    }
    status("Generate statistic list"); // 2007-12-19 alf@cadsoft.de

    // Stop/Cream mask statistic 2006-04-28
    sprintf(statisticSTOP_CREAM[0], "%d\t tStop Pad", padlSTOP[0]);
    sprintf(statisticSTOP_CREAM[1], "%d\t tStop Smd", smdlSTOP[0]);
    sprintf(statisticSTOP_CREAM[2], "%d\t tStop Pac", lSTOPpac[0]);      // tMask in Board/Package
    sprintf(statisticSTOP_CREAM[3], "%d\t tStop Brd", lSTOPbrd[0]);      // tMask in Board/Package
    sprintf(statisticSTOP_CREAM[4], "%d\t tStop", padlSTOP[0] + smdlSTOP[0] + lSTOPpac[0] + lSTOPbrd[0]);

    sprintf(statisticSTOP_CREAM[5], "%d\t bStop Pad", padlSTOP[1]);
    sprintf(statisticSTOP_CREAM[6], "%d\t bStop Smd", smdlSTOP[1]);
    sprintf(statisticSTOP_CREAM[7], "%d\t bStop Pac", lSTOPpac[1]);      // tMask in Board/Package
    sprintf(statisticSTOP_CREAM[8], "%d\t bStop Brd", lSTOPbrd[1]);      // tMask in Board/Package
    sprintf(statisticSTOP_CREAM[9], "%d\t bStop", padlSTOP[1] + smdlSTOP[1] + lSTOPpac[1] + lSTOPbrd[1]);

    sprintf(statisticSTOP_CREAM[10], "%d\t tCream Smd", smdlCREAM[0]);
    sprintf(statisticSTOP_CREAM[11], "%d\t tCream Pac", lCREAMpac[0]);     // tCream in Board/Package
    sprintf(statisticSTOP_CREAM[12], "%d\t tCream Brd", lCREAMbrd[0]);     // tCream in Board/Package
    sprintf(statisticSTOP_CREAM[13], "%d\t tCream", smdlCREAM[0] + lCREAMpac[0] + lCREAMbrd[0]);     // tCream in Board/Package

    sprintf(statisticSTOP_CREAM[14], "%d\t bCream Smd", smdlCREAM[1]);
    sprintf(statisticSTOP_CREAM[15], "%d\t bCream Pac", lCREAMpac[1]);     // bCream in Board/Package
    sprintf(statisticSTOP_CREAM[16], "%d\t bCream Brd", lCREAMbrd[1]);     // bCream in Board/Package
    sprintf(statisticSTOP_CREAM[17], "%d\t bCream", smdlCREAM[1] + lCREAMpac[1] + lCREAMbrd[1]);     // bCream in Board/Package


    // summary ******************
    string Tsummary_area;
    sprintf(Tsummary_area, "~ %.2f mm² (%.3f dm²)", summary_area, summary_area/10000.0);

    sprintf(sum, "%-6d\t Wire(s) incl. Arc(s)\n%-6d\t Polygon(s)\n_________________________\n" +
                 "%-6d\t SMD(s) top\n%-6d\t SMD(s) bottom\n===================\n%-6d\t SMD(s) total\n\n" +
                 "%-6d\t PAD(s)\n_________________________\n" +
                 "%-6d\t Via\n%-6d\t Hole\n===================\n" +
                 "%-6d\t Drills total\n_________________________\n"+
                 "%s\n%s\n_________________________\n" +
                 "Routing Info: \n%-6d\t Signal(s) \n" +
                 "%-6d\t PAD/SMD total\n===================\n" +
                 "%-6d\t PAD/SMD on Signal\n_________________________\n"+
                 "Packages used area:\n%s\n_________________________\n",
                  sumWires + sumARCw,
                  sumPOLYw,
                  cntSMDt,
                  cntSMDb,
                  sumSMD,
                  sumPADdril,
                  sumVIAdril,
                  sumHOLE,
                  sumPADdril + sumVIAdril + sumHOLE,
                  statisticSTOP_CREAM[13],        // 2006-04-28
                  statisticSTOP_CREAM[17],
                  sumSignals,
                  sumSMD + sumPADdril,
                  cnt_pad_on_signal,
                  Tsummary_area
           );

    sprintf(LabelcntRECT, "%d RECT (copper)", cntRECT);
    sprintf(LabelcntTextSize, "%d TEXT size (copper)", cntTextSize);
    sprintf(LabelcntTextWidth, "%d TEXT wire width (copper)", cntTextWidth);
    sprintf(LabelcntPlaceTextSize, "%d TEXT size (place)", cntPlaceTextSize);
    sprintf(LabelcntPlaceTextWidth, "%d TEXT wire width (place)", cntPlaceTextWidth);
    sprintf(LabelcntCIRCLE, "%d CICLE (copper)", cntCIRCLE);
    for (int ln = 1; ln < 16; ln++) {
      if (SupplyLayersUsedPolygons[ln]) {
        string sl;
        sprintf(sl, "%d:%s:(%d) ", ln, SupplyLayerName[ln], SupplyLayersUsedPolygons[ln]);
        checkSupplyLayerPolygon += sl;
      }
    }
    int Selected = 0;
    int StopCreamSelected = 0;
    int MCselected = 0;
    int ECselected = 0;
    // *********************************************************************
    dlgDialog("Statistic of " + B.name) {
      showminValWidth = check_min_ValueWidth();
      showminValOther = check_min_ValueOther();
      dlgHBoxLayout dlgSpacing(850);
      dlgHBoxLayout {
        dlgTabWidget {  // *** Board ***
          dlgTabPage("&BOARD") {
            dlgHBoxLayout {
              dlgSpacing(10);
              dlgVBoxLayout {
                dlgSpacing(10);
                dlgLabel(brdmaximum);
                dlgSpacing(5);
                dlgLabel(brdoutline);
                dlgLabel("<hr>");
                dlgLabel(usedLayer);
                dlgLabel(displayLayerError);
                dlgStretch(1);
              }
              dlgSpacing(10);
              dlgVBoxLayout {
                dlgGroup("Summary") {
                  dlgLabel(sum);
                  dlgHBoxLayout {
                    if (SignalUnrouted) {
                      dlgLabel(displayUnrouted);
                      dlgStretch(1);
                    }
                  }
                }
                dlgStretch(1);
              }
              dlgSpacing(5);
              dlgVBoxLayout {
                dlgGroup("Minor values") {
                  dlgHBoxLayout {
                    dlgVBoxLayout {
                      dlgLabel(showminValWidth, 1);
                      dlgHBoxLayout dlgSpacing(200);
                    }
                    dlgVBoxLayout {
                    dlgLabel(showminValOther, 1);
                    string emptyval = " ";
                    if (emptyValue) sprintf(emptyval, "%d <font color=red>%s</font>%s Values", emptyValue, empty, attention);
                    dlgSpacing(6);
                    dlgLabel(emptyval);
                  }
                }
                dlgSpacing(8);
                dlgHBoxLayout {
                  dlgPushButton("&Edit") {
                    GetCheckValues();
                    showminValWidth = check_min_ValueWidth();
                    showminValOther = check_min_ValueOther();
                  }
                  dlgStretch(1);
                }
              }
              if (PolyWidthError) dlgLabel("<b><font color=\"red\">" + PolygonError + "</font></b><br> Details see Tab POLYGON.");
            }
            dlgStretch(1);
          }
        }
        dlgTabPage("&LAYER") {   // *** all Layer are defined ***
          int layselect = 0;
          dlgHBoxLayout {
            dlgListView("Nb.:\tName\tUsed", allLayers, layselect ); // 2005-11-17 alf@cadsoft.de
            dlgStretch(1);
          }
        }

        dlgTabPage("&CLASS (Signal)") {   // *** Class clearance/isolate ***
          string classlabel = "Class 0: " + NetClassName[0];
          string ClassNameL = NetClassLabel(NetClassName[SignalClassSelect] , cNetClass[SignalClassSelect]);
          string SignalList = SignalClassList[selNetClassNr[SignalClassSelect]];
          dlgHBoxLayout {
            dlgVBoxLayout {
              dlgListView("", statisticCLASS, SignalClassSelect) {  // 2007-12-04 - Corrected Class handling to select net-list if classes empty
                SignalList = SignalClassList[selNetClassNr[SignalClassSelect]];
                sprintf(classlabel, "Class %d : %s",
                selNetClassNr[SignalClassSelect],
                NetClassName[selNetClassNr[SignalClassSelect]]);
              }
              dlgSpacing(12);
              if (falseSignalCnt) {
                dlgLabel("<font color=\"red\">False signals (not connected on PAD or SMD)</font>");
                dlgListView("", statisticFalseSignals, SignalClassSelect);
              }
              /********* 2009-02-12 *********/
              if (deleteRudimentalSignalName) {
                dlgLabel(" ");
                dlgLabel("<b>Found rudimentarily signal name(s).</b>");
                dlgLabel("You wish to delete this rudimentarily signal names, press button Delete");
                dlgPushButton("&Delete") {
                  dlgAccept();
                  exit("GRID MM;\n"+deleteRudimentalSignalName+"GRID LAST;\nRUN '"+filename(argv[0])+"'");
                }
              }
            }
            dlgSpacing(12);
            dlgGroup("Netlist") {
              dlgLabel(classlabel, 1);
              dlgHBoxLayout {
                dlgSpacing(4);
                dlgTextView(SignalList);
              }
            }
            dlgStretch(1);
          }
        }

        dlgTabPage("&WIDTH") {  // *** Wire / Text ***
          dlgHBoxLayout {
            dlgListView("", statisticWirew, Selected);
            dlgListView("", statisticARCw, Selected);
            dlgSpacing(8);
            dlgVBoxLayout {
              dlgListView("", statisticTEXTw, Selected);
              dlgLabel(LabelcntTextWidth);
            }
            dlgSpacing(8);
            dlgVBoxLayout {
              dlgListView("", statisticTEXTsize, Selected);
              dlgLabel(LabelcntTextSize);
            }
            dlgStretch(1);
          }
          dlgHBoxLayout {
            if (SignalUnrouted) {
              dlgSpacing(8);
              dlgLabel(displayUnrouted);
              dlgStretch(1);
            }
          }
          dlgLabel(wireWidthInternal);
        }

        dlgTabPage("POL&YGON") {  // *** Polygon ***
          int selp;
          dlgHBoxLayout {
            dlgListView("", statisticPolyw, Selected);
            dlgListView("", statisticPoliso, Selected);
            dlgSpacing(8);
            dlgVBoxLayout {
              dlgListView("Type\tName\tLayer\tRank\tWidth", PolygonLayer, Selected);
              if (PolyWidthError) dlgLabel("<b><font color=\"red\">" + PolygonError + "</font></b>");
              dlgLabel(wireWidthInternal);
            }
            dlgStretch(1);
          }
        }

        dlgTabPage("&SMD") {   // *** Smd ***
          dlgHBoxLayout {
            dlgListView("", statisticSMD, Selected);
            dlgStretch(2);
          }
        }

        dlgTabPage("&PAD") {  // *** Pad ***
          dlgHBoxLayout {
            dlgVBoxLayout {
              dlgListView("", statisticPADdiaTOP, Selected);
              dlgListView("", statisticPADdiaBOT, Selected);
            }
            dlgVBoxLayout {
              dlgListView("", statisticPADrestTOP, Selected);
              dlgListView("", statisticPADrestBOT, Selected);
            }
            dlgListView("", statisticPADdiaI, Selected);
            dlgListView("", statisticPADrestI, Selected);
            dlgStretch(1);
          }
        }

        dlgTabPage("&VIA") {  // *** Via ***
          dlgHBoxLayout {
            dlgVBoxLayout {
              dlgListView("", statisticVIAdia, Selected);
              dlgListView("", statisticVIArest, Selected);
            }
            dlgVBoxLayout {
              dlgListView("", statisticVIAdiaI, Selected);
              dlgListView("", statisticVIArestI, Selected);
            }
            dlgListView("", statisticVIAstack, Selected);
            dlgStretch(1);
          }
        }

        dlgTabPage("&DRILL/HOLE") {  // *** Drill Hole ***
          int plrSelected = -1;
          int vlrSelected = -1;
          int hlrSelected = -1;
          int lrSelected = -1;
          int vrSelected = -1;
          int shSel = 0;
          string StackHead = "RACK";
          dlgHBoxLayout {
            dlgListView("", statisticPADdril, plrSelected);
            dlgListView("", statisticVIAdril, vlrSelected);
            dlgListView("", statisticHOLE, hlrSelected);
            dlgListView("", drillRack, lrSelected);
            dlgSpacing(12);
            dlgListView("Layer/Rack", ViaStack, vrSelected) {
              StackHead = "RACK/"+ ViaStack[vrSelected] + "\tQ.";
              showLayerRack(vrSelected); //  + "\n" + StackDrills[rack]
            }
            dlgListView(StackHead, showStackDrills, shSel);
            //dlgStretch(1);
          }
        }

        dlgTabPage("&ELEMENT") {   // *** Element ***
          dlgHBoxLayout {
            dlgVBoxLayout {
              dlgHBoxLayout {
                dlgListView("", statisticLBR, LBRselected) {
                  art_selected = 1;
                  get_Info(art_selected, statisticLBR[LBRselected]);
                  dlgRedisplay();
                }
                dlgListView("", statisticPAC, PACselected) {
                  art_selected = 2;
                  get_Info(art_selected, statisticPAC[PACselected]);
                  dlgRedisplay();
                }
              }
              dlgHBoxLayout {
                dlgListView("", statisticValPacLay, VALselected) {
                  art_selected = 3;
                  get_Info(art_selected, statisticValPacLay[VALselected]);
                  dlgRedisplay();
                }
              }
            }
            dlgVBoxLayout {
              dlgHBoxLayout dlgSpacing(250);
              dlgLabel(linfo ,1);
              dlgSpacing(10);
              dlgTextView(Element_info);
            }
            dlgVBoxLayout {
              //dlgListView("Electrical", EContact, ECselected);  // 2009-12-02
              dlgListView("Mech. Part\tPac.", EnoContact, MCselected);
            }
          }
          dlgSpacing(8);
          dlgLabel(statisticLocked); // 2007-12-19 alf@cadsoft.de
          dlgSpacing(12);
          dlgLabel("<nobr>Packages used area <b>"+Tsummary_area+"</b></nobr>");
        }

        dlgTabPage("&MASK") {  // *** Stop & Cream MASK ***
          dlgHBoxLayout {
            dlgListView("Count\tLayer", statisticSTOP_CREAM, StopCreamSelected, msort);
            dlgStretch(1);
          }
        }

        dlgTabPage("&RECT CIRCLE") {  // *** Rect / Circle ***
          dlgHBoxLayout {
            dlgVBoxLayout {
              dlgListView("", statisticRECT, Selected);
              dlgLabel(LabelcntRECT);
            }
            dlgSpacing(8);
            dlgVBoxLayout {
              dlgListView("", statisticCIRw, Selected);
              dlgLabel(LabelcntCIRCLE);
            }
            dlgVBoxLayout {
              dlgListView("", statisticCIRdiam, Selected);
              dlgLabel(LabelcntCIRCLE);
            }
            dlgStretch(1);
          }
        }

        dlgTabPage("&TEXT") {  // *** Text ***
          dlgHBoxLayout {
            dlgVBoxLayout {
              dlgListView("", statisticPlaceTEXTw, Selected);
              dlgLabel(LabelcntPlaceTextWidth);
            }
            dlgVBoxLayout {
              dlgListView("", statisticPlaceTEXTsize, Selected);
              dlgLabel(LabelcntPlaceTextSize);
            }
            dlgStretch(1);
          }
        }
      }
    }
    if (checkSupplyLayerPolygon) dlgLabel("<font color=\"red\">Polygon(s) in SUPPLY-LAYER, please check! :</font><br><font color=\"blue\">" + checkSupplyLayerPolygon + "</font>");
    dlgHBoxLayout {
      dlgPushButton("-&Quit") dlgAccept();
      dlgPushButton("&Save report") {
        string fileName = dlgFileSave("Select a file", filesetext(brdfile,".rep"), "*.rep");
        if (fileName) {
          output(fileName, "wt") {
            printf("%s", saveReport());
          }
        }
      }
      dlgSpacing(50);
        dlgLabel("All Units = " + unit[uval]);
        dlgSpacing(50);
        dlgStretch(1);
        dlgLabel(Version);
      }
      dlgHBoxLayout {
        dlgLabel("Database:");
        dlgLabel(brdfile, 1);
        dlgStretch(1);
      }
    };
    exit (0);
  }
}

else dlgMessageBox("Start this  ULP from a Board", "OK");