if (year < 70)
if (year < 69)
__mktime_internal (struct tm *tp,		   struct tm *(*convert) (const time_t *, struct tm *),		   time_t *offset){  time_t t, dt, t0, t1, t2;  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,     leap seconds, and oscillations around a spring-forward gap.     POSIX.1 prohibits leap seconds, but some hosts have them anyway.  */  int remaining_probes = 6;  /* 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;  /* 1 if the previous probe was DST.  */  int dst2;  /* 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;  /* Only years after 1970 are defined.  */  if (year < 70)    return -1;#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 = t1 = t2 = t0 + *offset, dst2 = 0;       (dt = ydhms_tm_diff (year, yday, hour, min, sec,			    ranged_convert (convert, &t, &tm)));       t1 = t2, t2 = t, t += dt, dst2 = tm.tm_isdst != 0)    if (t == t1 && t != t2	&& (tm.tm_isdst < 0	    || (isdst < 0		? dst2 <= (tm.tm_isdst != 0)		: (isdst != 0) != (tm.tm_isdst != 0))))      /* We can't possibly find a match, as we are oscillating	 between two values.  The requested time probably falls	 within a spring-forward gap of size DT.  Follow the common	 practice in this case, which is to return a time that is DT	 away from the requested time, preferring a time whose	 tm_isdst differs from the requested value.  (If no tm_isdst	 was requested and only one of the two values has a nonzero	 tm_isdst, prefer that value.)  In practice, this is more	 useful than returning -1.  */      break;    else if (--remaining_probes == 0)      return -1;  /* If we have a match, check whether tm.tm_isdst has the requested     value, if any.  */  if (dt == 0 && isdst != tm.tm_isdst && 0 <= isdst && 0 <= tm.tm_isdst)    {      /* tm.tm_isdst has the wrong value.  Look for a neighboring	 time with the right value, and use its UTC offset.	 Heuristic: probe the previous three calendar quarters (approximately),	 looking for the desired isdst.  This isn't perfect,	 but it's good enough in practice.  */      int quarter = 7889238; /* seconds per average 1/4 Gregorian year */      int i;      /* If we're too close to the time_t limit, look in future quarters.  */      if (t < TIME_T_MIN + 3 * quarter)	quarter = -quarter;      for (i = 1; i <= 3; i++)	{	  time_t ot = t - i * quarter;	  struct tm otm;	  ranged_convert (convert, &ot, &otm);	  if (otm.tm_isdst == isdst)	    {	      /* We found the desired tm_isdst.		 Extrapolate back to the desired time.  */	      t = ot + ydhms_tm_diff (year, yday, hour, min, sec, &otm);	      ranged_convert (convert, &t, &tm);	      break;	    }	}    }  *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;}