* time is always equal to:
     *    fileTime + (current perf counter - lastCounter)
     *				* 10000000 / counterFreq
     */

    struct {
	ULONGLONG fileTime;
	ULONGLONG virtTime;
	volatile		/* used also to compare calibration epoch */
	LONGLONG perfCounter; 
	LONGLONG counterFreq;
    } lastCC;			/* Last data updated in calibration cycle */
    
    Tcl_WideInt lastUsedTime;	/* Last known (caller) virtual time in 100-ns
				 * (used to avoid drifts after calibrate) */

    (LARGE_INTEGER) (Tcl_WideInt) 0,
    (LARGE_INTEGER) (Tcl_WideInt) 0,
#else
    {0, 0},
    {0, 0},
#endif
    {
	(ULONGLONG) 0,
	(ULONGLONG) 0,
	(LONGLONG) 0,
	(LONGLONG) 0
    },
    (Tcl_WideInt) 0,
    { (Tcl_WideUInt) 0 },
    { (Tcl_WideInt) 0 },

 *----------------------------------------------------------------------
 *
 * NativeCalc100NsTicks --
 *
 *	Calculate the current system time in 100-ns ticks since posix epoch,
 *	for current performance counter (curCounter), using given calibrated values.
 *
 *	vt = lastCC.virtTime + 
 *	     10000000 * (curPerfCounter - lastCC.perfCounter) / lastCC.counterFreq
 *
 * Results:
 *	Returns the wide integer with number of microseconds from the epoch.
 *
 * Side effects:
 *	None
 *
 *----------------------------------------------------------------------
 */

static inline Tcl_WideInt
NativeCalc100NsTicks(
    ULONGLONG ccVirtTime,
    LONGLONG ccPerfCounter,
    LONGLONG ccCounterFreq,
    LONGLONG curCounter
) {
    return ccVirtTime + 
	((curCounter - ccPerfCounter) * 10000000 / ccCounterFreq);
}

/*
 * Representing the number of 100-nanosecond intervals since posix epoch.
 */
static inline Tcl_WideInt

	QueryPerformanceCounter(&newPerfCounter);

    	if (prevUS && usecSincePosixEpoch < prevUS) {
    	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! pre-struct: %I64d, %I64d, %I64d, %I64d == %I64d \n", fileTimeLastCall, perfCounterLastCall, prevPerfCounter.QuadPart, curCounterFreq,
    	    	NativeCalc100NsTicks(fileTimeLastCall,
		perfCounterLastCall, curCounterFreq,
		prevPerfCounter.QuadPart));
    	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! new-struct: %I64d, %I64d, %I64d, %I64d == %I64d \n", timeInfo.lastCC.virtTime, timeInfo.lastCC.perfCounter, newPerfCounter.QuadPart, timeInfo.lastCC.counterFreq,
    	    	NativeCalc100NsTicks(timeInfo.lastCC.virtTime,
		timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq,
		newPerfCounter.QuadPart));
	    printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!time-backwards!!!! prev: %I64d - now: %I64d (%I64d usec)\n", prevUS, usecSincePosixEpoch, usecSincePosixEpoch - prevUS);
	    Tcl_Panic("Time running backwards!!!");
    	}
    	prevUS = usecSincePosixEpoch;
	fileTimeLastCall = timeInfo.lastCC.virtTime;
	perfCounterLastCall = timeInfo.lastCC.perfCounter;
	curCounterFreq = timeInfo.lastCC.counterFreq;
	prevPerfCounter.QuadPart = newPerfCounter.QuadPart;

	return usecSincePosixEpoch;
}


	}
	TclpInitUnlock();
    }

    if (timeInfo.perfCounterAvailable && timeInfo.lastCC.counterFreq!=0) {

	static struct {
	    ULONGLONG virtTime;
	    volatile		/* don't optimize */
	    LONGLONG  perfCounter;
	    LONGLONG  counterFreq;
	    Tcl_WideInt calibNextTime;
	} cc = {0, 0, 0, 0};	/* Copy with current data of calibration cycle */

	LARGE_INTEGER curCounter;
				/* Current performance counter. */

	/*
	 * Hold time section locked as short as possible
	 */
	if (cc.perfCounter != timeInfo.lastCC.perfCounter) {
	    EnterCriticalSection(&timeInfo.cs);
	    if (cc.perfCounter != timeInfo.lastCC.perfCounter) {
		cc.perfCounter = timeInfo.lastCC.perfCounter;
		cc.virtTime = timeInfo.lastCC.virtTime;
		cc.counterFreq = timeInfo.lastCC.counterFreq;
		cc.calibNextTime = timeInfo.calibNextTime;
	    }
	    LeaveCriticalSection(&timeInfo.cs);
	}

	/*
	 * Query the performance counter and use it to calculate the current
	 * time.
	 */
	QueryPerformanceCounter(&curCounter);

	/* Calibrated file-time is saved from posix in 100-ns ticks */
	curTime = NativeCalc100NsTicks(cc.virtTime,
		cc.perfCounter, cc.counterFreq, curCounter.QuadPart);

	/* Be sure the clock ticks never backwards (avoid backwards time-drifts) */
	if ( (lastTime = timeInfo.lastUsedTime)
	  && lastTime > curTime
	  && lastTime - curTime < 1000000 /* bypass time-switch (drifts only) */
	) {

     */

    LARGE_INTEGER curPerfCounter;

    QueryPerformanceCounter(&curPerfCounter);
    timeInfo.lastCC.perfCounter = curPerfCounter.QuadPart;
    timeInfo.lastCC.counterFreq = timeInfo.nominalFreq.QuadPart;
    timeInfo.lastCC.fileTime = timeInfo.lastCC.virtTime = GetSystemTimeAsVirtual();

    ResetCounterSamples(timeInfo.lastCC.fileTime,
	    timeInfo.lastCC.perfCounter,
	    timeInfo.lastCC.counterFreq);

    /*
     * Calibrate first time and wake up the calling thread. 

static void
UpdateTimeEachSecond(void)
{
    LARGE_INTEGER curPerfCounter;
				/* Current value returned from
				 * QueryPerformanceCounter. */
    static Tcl_WideInt lastDiff = 0;
    				/* Last difference between system clock and Tcl
				 * time. */
    static int calibrationInterv = 10000000;
				/* Calibration interval in 100-ns ticks (starts from 1s) */
    Tcl_WideInt curFileTime;	/* File time at the time this callback was
				 * scheduled. */
    Tcl_WideInt estFreq;	/* Estimated perf counter frequency. */
    int		driftBack;	/* Sign the virtual time may drift backwards */
    Tcl_WideInt vt0;		/* Tcl time right now. */

    QueryPerformanceCounter(&curPerfCounter);

    /* 
     * Current virtual time:
     * vt0 = lastCC.fileTime +
     *       10000000 * (curPerfCounter - lastCC.perfCounter) / lastCC.counterFreq
     */
    vt0 = NativeCalc100NsTicks((timeInfo.lastCC.fileTime/2 + timeInfo.lastCC.virtTime/2),
	    timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq,
	    curPerfCounter.QuadPart);

    tdiff = vt0 - curFileTime; /* discrepancy between virtual and real-time */
    if (tdiff >= 10000000 || tdiff <= -10000000) {
	printf("---!!!!!!!---calibration ERR, tdiff %I64d\n", tdiff);
    }
    /* 
     * If calibration still not needed (check for possible time-switch). Note, that
     * NativeGetMicroseconds checks calibNextTime also, be sure it does not overflow.
     * Calibrate immediately if we've too large discrepancy to the real-time (15.6 ms).
     */
#if 0
    if ( curFileTime < timeInfo.calibNextTime - (10000000/2) /* 0.5 sec (in 100-ns ticks). */
      && timeInfo.calibNextTime - curFileTime < 10 * 10000000 /* max. 10 seconds in-between (time-switch?) */
      && tdiff > -156000 && tdiff < 156000 /* small discrepancy */
      && (tdiff >= 0 && tdiff <= lastDiff / 3 * 2 || tdiff < 0 && tdiff >= lastDiff / 3 * 2) /* more precise now */
    ) {
    	/* again in next one second */
    	printf("-------------calibration end, tdiff %I64d, *** not needed. (next in: %I64d) ------\n", tdiff, curFileTime, timeInfo.calibNextTime, timeInfo.calibNextTime - curFileTime);
	lastDiff = tdiff;
	return;
    }
#endif
    /*
     * We devide by timeInfo.lastCC.counterFreq in several places. That
     * value should always be positive on a correctly functioning system. But
     * it is good to be defensive about such matters. So if something goes
     * wrong and the value does goes to zero, we clear the
     * timeInfo.perfCounterAvailable in order to cause the calibration thread
     * to shut itself down, then return without additional processing.

     *
     * Store the current sample into the circular buffer of samples, and
     * estimate the performance counter frequency.
     */
#if 0
    estFreq = AccumulateSample(curPerfCounter.QuadPart, curFileTime);
#else
    vt1 = curFileTime - timeInfo.lastCC.fileTime;
    if (vt1) {
	estFreq = 10000000 * (curPerfCounter.QuadPart - timeInfo.lastCC.perfCounter) / vt1;
#if 1
	
	/* 
	 * Minimize influence of estFreq if tdiff falls (in relation to last difference),
	 * with dual falling speed. This indicates better choice of lastCC.counterFreq.
	 */
	if (tdiff > 0 && tdiff < lastDiff / 2 || tdiff < 0 && tdiff > lastDiff / 2) {
	    printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, lastDiff);
	    estFreq = (estFreq + timeInfo.lastCC.counterFreq * 2) / 3;
	    printf("-----***-----calibration minimize %I64d, %I64d\n", estFreq, tdiff);
	}
#endif
    } else {
    	estFreq = timeInfo.lastCC.counterFreq;
    }
    //printf("------**-----calibration estimated, tdiff: %I64d, ** %s ** cntrDiff:%I64d\n", tdiff, (estFreq > timeInfo.lastCC.counterFreq) ? "^^^" : "vvv", (curPerfCounter.QuadPart - timeInfo.lastCC.perfCounter));
    //printf("------**-----calibration estimated Frequency %I64d, %I64d, %I64d, diff: %I64d\n", curFileTime, curPerfCounter.QuadPart, estFreq, estFreq - timeInfo.lastCC.counterFreq);
#endif

    driftBack = 0;

    /*
     * We want to adjust things so that time appears to be continuous.
     * Virtual file time, right now, is vt0.

     */

    if (tdiff > 10000000 || tdiff < -10000000) {
    	/* More as a second difference, so could be a time-switch
    	/* jump to current system time, use curent estimated frequency */
    	vt0 = curFileTime;
    	timeInfo.lastUsedTime = 0; /* reset last used time */
    	estFreq = timeInfo.nominalFreq.QuadPart;
    } else {
	Tcl_WideInt driftFreq;	/* Frequency needed to drift virtual time into
				 * step over 1 second. */

    	/* calculate new frequency and estimate drift to the next second */
	vt1 = 20000000 + curFileTime;
	driftFreq = (estFreq * 20000000 / (vt1 - vt0));
	/* 
	 * Avoid too large drifts (only half of the current difference),
	 * that allows also be more accurate (aspire to the smallest tdiff),
	 * so then we can prolong calibration interval in such cases.
	 */
	driftFreq = timeInfo.lastCC.counterFreq +
		(driftFreq - timeInfo.lastCC.counterFreq) / 2;

	/* 
	 * Average between estimated, 2 current and 5 drifted frequencies,
	 * (do the soft drifting as possible).
	 * Minimize influence if tdiff falls (in relation to last difference)
	 */
#if 0
	if (tdiff > 0 && tdiff < lastDiff / 2 || tdiff < 0 && tdiff > lastDiff / 2) {
	    estFreq = (1 * estFreq + 2 * timeInfo.lastCC.counterFreq + 5 * driftFreq) / 8;
	} else {
	    estFreq = (3 * estFreq + 3 * timeInfo.lastCC.counterFreq + 2 * driftFreq) / 8;
	}
#else
	estFreq = (estFreq + timeInfo.lastCC.counterFreq + driftFreq) / 3;
#endif
    }
    
    /* 
     * Avoid too large discrepancy from nominal frequency (0.5%)
     */
    if ( estFreq > (vt1 = (1000+5)*timeInfo.nominalFreq.QuadPart/1000)
      || estFreq < (vt1 = (1000-5)*timeInfo.nominalFreq.QuadPart/1000)
    ) {
	estFreq = vt1;
	driftBack = vt0 > curFileTime;
	vt0 = curFileTime; /* too large - just reset */
    }

    /* If possible backwards time-drifts (larger divider now) */
    vt1 = 0;
    if (1 || driftBack || estFreq > timeInfo.lastCC.counterFreq) {
	Tcl_WideInt nt0, nt1;

	/* 
	 * Calculate the time using new calibration values (and compare with old),
	 * to avoid possible backwards drifts (adjust current base time).
	 * This should affect at least next 10 ticks.
	 */
	vt1 = curPerfCounter.QuadPart + 10;
	/*
	 * Be sure the clock ticks never backwards (avoid it by negative drifting)
	 * just compare native time (in 100-ns) before and hereafter using 
	 * previous/new calibrated values) and do a small adjustment
	 */
	nt0 = NativeCalc100NsTicks(timeInfo.lastCC.virtTime,
		timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq,
		vt1);
	nt1 = NativeCalc100NsTicks(vt0,
		curPerfCounter.QuadPart, estFreq,
		vt1);
	vt1 = (nt0 - nt1); /* old time - new time */
	if (vt1 > 0 && vt1 < 10000000 /* bypass time-switch */) {
	    /* base time should jump forwards (the same virtual time using current values) */
	    vt0 += vt1;
	    tdiff += vt1;
	    //////////////////////////////////////////estFreq = 10000000 * (vt0 - timeInfo.lastCC.perfCounter) / vt1;
	}
    }

    /* if still precise enough, grow calibration interval up to 10 seconds */
    if (tdiff < -156000 || tdiff > 156000 /* 15.6-ms */) {
	/* too long drift - reset calibration interval to 1 second */
	calibrationInterv = 10000000;
    } else if (calibrationInterv < 10*10000000) {
	calibrationInterv += 10000000;
    }

    lastDiff = tdiff;

    /* In lock commit new values to timeInfo (hold lock as short as possible) */
    EnterCriticalSection(&timeInfo.cs);

    timeInfo.lastCC.perfCounter = curPerfCounter.QuadPart;
    timeInfo.lastCC.fileTime = curFileTime;
    timeInfo.lastCC.virtTime = vt0;
    timeInfo.lastCC.counterFreq = estFreq;

    timeInfo.calibNextTime = curFileTime + calibrationInterv;

    LeaveCriticalSection(&timeInfo.cs);
#if 1
    //printf("-------------calibration adj -- nt1:%I64d - nt0:%I64d: adj: %I64d\n", nt1, nt0, vt1);
    printf("-------------calibration end, tdiff %I64d, jump -- vt:%I64d - st:%I64d: %I64d, adj: %I64d\n", tdiff, 
    	vt0, curFileTime, (vt0 - curFileTime), vt1);
    printf("-------------calibration end  ,  new-struct: %I64d, %I64d, %I64d\n", timeInfo.lastCC.virtTime, timeInfo.lastCC.perfCounter, timeInfo.lastCC.counterFreq);
#endif
}

/*
 *----------------------------------------------------------------------
 *
 * ResetCounterSamples --

    PCdiff = perfCounter - lastPCSample;
    FTdiff = fileTime - lastFTSample;
    if (PCdiff < timeInfo.nominalFreq.QuadPart * 9 / 10
	    || PCdiff > timeInfo.nominalFreq.QuadPart * 11 / 10
	    || FTdiff < 9000000 || FTdiff > 11000000) {
	ResetCounterSamples(fileTime, perfCounter,
		timeInfo.nominalFreq.QuadPart);
#if 0
	FTdiff = fileTime - timeInfo.lastCC.fileTime;
	if (FTdiff) {
	    estFreq = 10000000 * (perfCounter - timeInfo.lastCC.perfCounter) / FTdiff;
	    printf("------**-----calibration estimated Frequency %I64d, %I64d, %I64d, diff: %I64d\n", fileTime, perfCounter, estFreq, estFreq - timeInfo.lastCC.counterFreq);
	}
	return (timeInfo.nominalFreq.QuadPart + timeInfo.lastCC.counterFreq) / 2;
#endif
	return timeInfo.nominalFreq.QuadPart;
    } else {
	/*
	 * Estimate the frequency.
	 */

	workPCSample = timeInfo.perfCounterSample[timeInfo.sampleNo];