t += dt) if (--remaining_probes == 0)
t1 = t2, t2 = t, t += dt) if (t == t1 && t != t2 && (isdst < 0 || tm.tm_isdst < 0 || (isdst != 0) != (tm.tm_isdst != 0)))  break; else if (--remaining_probes == 0)
__mktime_internal (tp, convert, offset)     struct tm *tp;     struct tm *(*convert) __P ((const time_t *, struct tm *));     time_t *offset;{  time_t t, dt, t0;  struct tm tm;  /* The maximum number of probes (calls to CONVERT) should be enough     to handle any combinations of time zone rule changes, solar time,     and leap seconds.  POSIX.1 prohibits leap seconds, but some hosts     have them anyway.  */  int remaining_probes = 4;  /* Time requested.  Copy it in case CONVERT modifies *TP; this can     occur if TP is localtime's returned value and CONVERT is localtime.  */  int sec = tp->tm_sec;  int min = tp->tm_min;  int hour = tp->tm_hour;  int mday = tp->tm_mday;  int mon = tp->tm_mon;  int year_requested = tp->tm_year;  int isdst = tp->tm_isdst;  /* Ensure that mon is in range, and set year accordingly.  */  int mon_remainder = mon % 12;  int negative_mon_remainder = mon_remainder < 0;  int mon_years = mon / 12 - negative_mon_remainder;  int year = year_requested + mon_years;  /* The other values need not be in range:     the remaining code handles minor overflows correctly,     assuming int and time_t arithmetic wraps around.     Major overflows are caught at the end.  */  /* Calculate day of year from year, month, and day of month.     The result need not be in range.  */  int yday = ((__mon_yday[__isleap (year + TM_YEAR_BASE)]	       [mon_remainder + 12 * negative_mon_remainder])	      + mday - 1);  int sec_requested = sec;#if LEAP_SECONDS_POSSIBLE  /* Handle out-of-range seconds specially,     since ydhms_tm_diff assumes every minute has 60 seconds.  */  if (sec < 0)    sec = 0;  if (59 < sec)    sec = 59;#endif  /* Invert CONVERT by probing.  First assume the same offset as last time.     Then repeatedly use the error to improve the guess.  */  tm.tm_year = EPOCH_YEAR - TM_YEAR_BASE;  tm.tm_yday = tm.tm_hour = tm.tm_min = tm.tm_sec = 0;  t0 = ydhms_tm_diff (year, yday, hour, min, sec, &tm);  for (t = t0 + *offset;       (dt = ydhms_tm_diff (year, yday, hour, min, sec,			    ranged_convert (convert, &t, &tm)));       t += dt)    if (--remaining_probes == 0)      return -1;  /* Check whether tm.tm_isdst has the requested value, if any.  */  if (0 <= isdst && 0 <= tm.tm_isdst)    {      int dst_diff = (isdst != 0) - (tm.tm_isdst != 0);      if (dst_diff)	{	  /* Move two hours in the direction indicated by the disagreement,	     probe some more, and switch to a new time if found.	     The largest known fallback due to daylight savings is two hours:	     once, in Newfoundland, 1988-10-30 02:00 -> 00:00.  */	  time_t ot = t - 2 * 60 * 60 * dst_diff;	  while (--remaining_probes != 0)	    {	      struct tm otm;	      if (! (dt = ydhms_tm_diff (year, yday, hour, min, sec,					 ranged_convert (convert, &ot, &otm))))		{		  t = ot;		  tm = otm;		  break;		}	      if ((ot += dt) == t)		break;  /* Avoid a redundant probe.  */	    }	}    }  *offset = t - t0;#if LEAP_SECONDS_POSSIBLE  if (sec_requested != tm.tm_sec)    {      /* Adjust time to reflect the tm_sec requested, not the normalized value.	 Also, repair any damage from a false match due to a leap second.  */      t += sec_requested - sec + (sec == 0 && tm.tm_sec == 60);      if (! (*convert) (&t, &tm))	return -1;    }#endif  if (TIME_T_MAX / INT_MAX / 366 / 24 / 60 / 60 < 3)    {      /* time_t isn't large enough to rule out overflows in ydhms_tm_diff,	 so check for major overflows.  A gross check suffices,	 since if t has overflowed, it is off by a multiple of	 TIME_T_MAX - TIME_T_MIN + 1.  So ignore any component of	 the difference that is bounded by a small value.  */      double dyear = (double) year_requested + mon_years - tm.tm_year;      double dday = 366 * dyear + mday;      double dsec = 60 * (60 * (24 * dday + hour) + min) + sec_requested;      /* On Irix4.0.5 cc, dividing TIME_T_MIN by 3 does not produce	 correct results, ie., it erroneously gives a positive value	 of 715827882.  Setting a variable first then doing math on it	 seems to work.  (ghazi@caip.rutgers.edu) */      const time_t time_t_max = TIME_T_MAX;      const time_t time_t_min = TIME_T_MIN;      if (time_t_max / 3 - time_t_min / 3 < (dsec < 0 ? - dsec : dsec))	return -1;    }  *tp = tm;  return t;}