gt:                             min = (byte) n;
context: /*
   * Copyright (c) 1994, 2013, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
   * particular file as subject to the "Classpath" exception as provided
   * by Oracle in the LICENSE file that accompanied this code.
   *
   * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  package java.util;
  
  import java.text.DateFormat;
  import java.time.LocalDate;
  import java.io.IOException;
  import java.io.ObjectOutputStream;
  import java.io.ObjectInputStream;
  import java.lang.ref.SoftReference;
  import java.time.Instant;
  import sun.util.calendar.BaseCalendar;
  import sun.util.calendar.CalendarDate;
  import sun.util.calendar.CalendarSystem;
  import sun.util.calendar.CalendarUtils;
  import sun.util.calendar.Era;
  import sun.util.calendar.Gregorian;
  import sun.util.calendar.ZoneInfo;
  
  /**
   * The class {@code Date} represents a specific instant
   * in time, with millisecond precision.
   * <p>
   * Prior to JDK&nbsp;1.1, the class {@code Date} had two additional
   * functions.  It allowed the interpretation of dates as year, month, day, hour,
   * minute, and second values.  It also allowed the formatting and parsing
   * of date strings.  Unfortunately, the API for these functions was not
   * amenable to internationalization.  As of JDK&nbsp;1.1, the
   * {@code Calendar} class should be used to convert between dates and time
   * fields and the {@code DateFormat} class should be used to format and
   * parse date strings.
   * The corresponding methods in {@code Date} are deprecated.
   * <p>
   * Although the {@code Date} class is intended to reflect
   * coordinated universal time (UTC), it may not do so exactly,
   * depending on the host environment of the Java Virtual Machine.
   * Nearly all modern operating systems assume that 1&nbsp;day&nbsp;=
   * 24&nbsp;&times;&nbsp;60&nbsp;&times;&nbsp;60&nbsp;= 86400 seconds
   * in all cases. In UTC, however, about once every year or two there
   * is an extra second, called a "leap second." The leap
   * second is always added as the last second of the day, and always
   * on December 31 or June 30. For example, the last minute of the
   * year 1995 was 61 seconds long, thanks to an added leap second.
   * Most computer clocks are not accurate enough to be able to reflect
   * the leap-second distinction.
   * <p>
   * Some computer standards are defined in terms of Greenwich mean
   * time (GMT), which is equivalent to universal time (UT).  GMT is
   * the "civil" name for the standard; UT is the
   * "scientific" name for the same standard. The
   * distinction between UTC and UT is that UTC is based on an atomic
   * clock and UT is based on astronomical observations, which for all
   * practical purposes is an invisibly fine hair to split. Because the
   * earth's rotation is not uniform (it slows down and speeds up
   * in complicated ways), UT does not always flow uniformly. Leap
   * seconds are introduced as needed into UTC so as to keep UTC within
   * 0.9 seconds of UT1, which is a version of UT with certain
   * corrections applied. There are other time and date systems as
   * well; for example, the time scale used by the satellite-based
   * global positioning system (GPS) is synchronized to UTC but is
   * <i>not</i> adjusted for leap seconds. An interesting source of
   * further information is the U.S. Naval Observatory, particularly
   * the Directorate of Time at:
   * <blockquote><pre>
   *     <a href=http://tycho.usno.navy.mil>http://tycho.usno.navy.mil</a>
   * </pre></blockquote>
   * <p>
   * and their definitions of "Systems of Time" at:
   * <blockquote><pre>
   *     <a href=http://tycho.usno.navy.mil/systime.html>http://tycho.usno.navy.mil/systime.html</a>
   * </pre></blockquote>
   * <p>
   * In all methods of class {@code Date} that accept or return
   * year, month, date, hours, minutes, and seconds values, the
   * following representations are used:
   * <ul>
   * <li>A year <i>y</i> is represented by the integer
   *     <i>y</i>&nbsp;{@code - 1900}.
   * <li>A month is represented by an integer from 0 to 11; 0 is January,
   *     1 is February, and so forth; thus 11 is December.
   * <li>A date (day of month) is represented by an integer from 1 to 31
   *     in the usual manner.
   * <li>An hour is represented by an integer from 0 to 23. Thus, the hour
   *     from midnight to 1 a.m. is hour 0, and the hour from noon to 1
   *     p.m. is hour 12.
   * <li>A minute is represented by an integer from 0 to 59 in the usual manner.
   * <li>A second is represented by an integer from 0 to 61; the values 60 and
   *     61 occur only for leap seconds and even then only in Java
   *     implementations that actually track leap seconds correctly. Because
   *     of the manner in which leap seconds are currently introduced, it is
   *     extremely unlikely that two leap seconds will occur in the same
   *     minute, but this specification follows the date and time conventions
   *     for ISO C.
   * </ul>
   * <p>
   * In all cases, arguments given to methods for these purposes need
   * not fall within the indicated ranges; for example, a date may be
   * specified as January 32 and is interpreted as meaning February 1.
   *
   * @author  James Gosling
   * @author  Arthur van Hoff
   * @author  Alan Liu
   * @see     java.text.DateFormat
   * @see     java.util.Calendar
   * @see     java.util.TimeZone
   * @since   1.0
   */
  public class Date
      implements java.io.Serializable, Cloneable, Comparable<Date>
  {
      private static final BaseCalendar gcal =
                                  CalendarSystem.getGregorianCalendar();
      private static BaseCalendar jcal;
  
      private transient long fastTime;
  
      /*
       * If cdate is null, then fastTime indicates the time in millis.
       * If cdate.isNormalized() is true, then fastTime and cdate are in
       * synch. Otherwise, fastTime is ignored, and cdate indicates the
       * time.
       */
      private transient BaseCalendar.Date cdate;
  
      // Initialized just before the value is used. See parse().
      private static int defaultCenturyStart;
  
      /* use serialVersionUID from modified java.util.Date for
       * interoperability with JDK1.1. The Date was modified to write
       * and read only the UTC time.
       */
      private static final long serialVersionUID = 7523967970034938905L;
  
      /**
       * Allocates a {@code Date} object and initializes it so that
       * it represents the time at which it was allocated, measured to the
       * nearest millisecond.
       *
       * @see     java.lang.System#currentTimeMillis()
       */
      public Date() {
          this(System.currentTimeMillis());
      }
  
      /**
       * Allocates a {@code Date} object and initializes it to
       * represent the specified number of milliseconds since the
       * standard base time known as "the epoch", namely January 1,
       * 1970, 00:00:00 GMT.
       *
       * @param   date   the milliseconds since January 1, 1970, 00:00:00 GMT.
       * @see     java.lang.System#currentTimeMillis()
       */
      public Date(long date) {
          fastTime = date;
      }
  
      /**
       * Allocates a {@code Date} object and initializes it so that
       * it represents midnight, local time, at the beginning of the day
       * specified by the {@code year}, {@code month}, and
       * {@code date} arguments.
       *
       * @param   year    the year minus 1900.
       * @param   month   the month between 0-11.
       * @param   date    the day of the month between 1-31.
       * @see     java.util.Calendar
       * @deprecated As of JDK version 1.1,
       * replaced by {@code Calendar.set(year + 1900, month, date)}
       * or {@code GregorianCalendar(year + 1900, month, date)}.
       */
      @Deprecated
      public Date(int year, int month, int date) {
          this(year, month, date, 0, 0, 0);
      }
  
      /**
       * Allocates a {@code Date} object and initializes it so that
       * it represents the instant at the start of the minute specified by
       * the {@code year}, {@code month}, {@code date},
       * {@code hrs}, and {@code min} arguments, in the local
       * time zone.
       *
       * @param   year    the year minus 1900.
       * @param   month   the month between 0-11.
       * @param   date    the day of the month between 1-31.
       * @param   hrs     the hours between 0-23.
       * @param   min     the minutes between 0-59.
       * @see     java.util.Calendar
       * @deprecated As of JDK version 1.1,
       * replaced by {@code Calendar.set(year + 1900, month, date, hrs, min)}
       * or {@code GregorianCalendar(year + 1900, month, date, hrs, min)}.
       */
      @Deprecated
      public Date(int year, int month, int date, int hrs, int min) {
          this(year, month, date, hrs, min, 0);
      }
  
      /**
       * Allocates a {@code Date} object and initializes it so that
       * it represents the instant at the start of the second specified
       * by the {@code year}, {@code month}, {@code date},
       * {@code hrs}, {@code min}, and {@code sec} arguments,
       * in the local time zone.
       *
       * @param   year    the year minus 1900.
       * @param   month   the month between 0-11.
       * @param   date    the day of the month between 1-31.
       * @param   hrs     the hours between 0-23.
       * @param   min     the minutes between 0-59.
       * @param   sec     the seconds between 0-59.
       * @see     java.util.Calendar
       * @deprecated As of JDK version 1.1,
       * replaced by {@code Calendar.set(year + 1900, month, date, hrs, min, sec)}
       * or {@code GregorianCalendar(year + 1900, month, date, hrs, min, sec)}.
       */
      @Deprecated
      public Date(int year, int month, int date, int hrs, int min, int sec) {
          int y = year + 1900;
          // month is 0-based. So we have to normalize month to support Long.MAX_VALUE.
          if (month >= 12) {
              y += month / 12;
              month %= 12;
          } else if (month < 0) {
              y += CalendarUtils.floorDivide(month, 12);
              month = CalendarUtils.mod(month, 12);
          }
          BaseCalendar cal = getCalendarSystem(y);
          cdate = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.getDefaultRef());
          cdate.setNormalizedDate(y, month + 1, date).setTimeOfDay(hrs, min, sec, 0);
          getTimeImpl();
          cdate = null;
      }
  
      /**
       * Allocates a {@code Date} object and initializes it so that
       * it represents the date and time indicated by the string
       * {@code s}, which is interpreted as if by the
       * {@link Date#parse} method.
       *
       * @param   s   a string representation of the date.
       * @see     java.text.DateFormat
       * @see     java.util.Date#parse(java.lang.String)
       * @deprecated As of JDK version 1.1,
       * replaced by {@code DateFormat.parse(String s)}.
       */
      @Deprecated
      public Date(String s) {
          this(parse(s));
      }
  
      /**
       * Return a copy of this object.
       */
      public Object clone() {
          Date d = null;
          try {
              d = (Date)super.clone();
              if (cdate != null) {
                  d.cdate = (BaseCalendar.Date) cdate.clone();
              }
          } catch (CloneNotSupportedException e) {} // Won't happen
          return d;
      }
  
      /**
       * Determines the date and time based on the arguments. The
       * arguments are interpreted as a year, month, day of the month,
       * hour of the day, minute within the hour, and second within the
       * minute, exactly as for the {@code Date} constructor with six
       * arguments, except that the arguments are interpreted relative
       * to UTC rather than to the local time zone. The time indicated is
       * returned represented as the distance, measured in milliseconds,
       * of that time from the epoch (00:00:00 GMT on January 1, 1970).
       *
       * @param   year    the year minus 1900.
       * @param   month   the month between 0-11.
       * @param   date    the day of the month between 1-31.
       * @param   hrs     the hours between 0-23.
       * @param   min     the minutes between 0-59.
       * @param   sec     the seconds between 0-59.
       * @return  the number of milliseconds since January 1, 1970, 00:00:00 GMT for
       *          the date and time specified by the arguments.
       * @see     java.util.Calendar
       * @deprecated As of JDK version 1.1,
       * replaced by {@code Calendar.set(year + 1900, month, date, hrs, min, sec)}
       * or {@code GregorianCalendar(year + 1900, month, date, hrs, min, sec)}, using a UTC
       * {@code TimeZone}, followed by {@code Calendar.getTime().getTime()}.
       */
      @Deprecated
      public static long UTC(int year, int month, int date,
                             int hrs, int min, int sec) {
          int y = year + 1900;
          // month is 0-based. So we have to normalize month to support Long.MAX_VALUE.
          if (month >= 12) {
              y += month / 12;
              month %= 12;
          } else if (month < 0) {
              y += CalendarUtils.floorDivide(month, 12);
              month = CalendarUtils.mod(month, 12);
          }
          int m = month + 1;
          BaseCalendar cal = getCalendarSystem(y);
          BaseCalendar.Date udate = (BaseCalendar.Date) cal.newCalendarDate(null);
          udate.setNormalizedDate(y, m, date).setTimeOfDay(hrs, min, sec, 0);
  
          // Use a Date instance to perform normalization. Its fastTime
          // is the UTC value after the normalization.
          Date d = new Date(0);
          d.normalize(udate);
          return d.fastTime;
      }
  
      /**
       * Attempts to interpret the string {@code s} as a representation
       * of a date and time. If the attempt is successful, the time
       * indicated is returned represented as the distance, measured in
       * milliseconds, of that time from the epoch (00:00:00 GMT on
       * January 1, 1970). If the attempt fails, an
       * {@code IllegalArgumentException} is thrown.
       * <p>
       * It accepts many syntaxes; in particular, it recognizes the IETF
       * standard date syntax: "Sat, 12 Aug 1995 13:30:00 GMT". It also
       * understands the continental U.S. time-zone abbreviations, but for
       * general use, a time-zone offset should be used: "Sat, 12 Aug 1995
       * 13:30:00 GMT+0430" (4 hours, 30 minutes west of the Greenwich
       * meridian). If no time zone is specified, the local time zone is
       * assumed. GMT and UTC are considered equivalent.
       * <p>
       * The string {@code s} is processed from left to right, looking for
       * data of interest. Any material in {@code s} that is within the
       * ASCII parenthesis characters {@code (} and {@code )} is ignored.
       * Parentheses may be nested. Otherwise, the only characters permitted
       * within {@code s} are these ASCII characters:
       * <blockquote><pre>
       * abcdefghijklmnopqrstuvwxyz
       * ABCDEFGHIJKLMNOPQRSTUVWXYZ
       * 0123456789,+-:/</pre></blockquote>
       * and whitespace characters.<p>
       * A consecutive sequence of decimal digits is treated as a decimal
       * number:<ul>
       * <li>If a number is preceded by {@code +} or {@code -} and a year
       *     has already been recognized, then the number is a time-zone
       *     offset. If the number is less than 24, it is an offset measured
       *     in hours. Otherwise, it is regarded as an offset in minutes,
       *     expressed in 24-hour time format without punctuation. A
       *     preceding {@code -} means a westward offset. Time zone offsets
       *     are always relative to UTC (Greenwich). Thus, for example,
       *     {@code -5} occurring in the string would mean "five hours west
       *     of Greenwich" and {@code +0430} would mean "four hours and
       *     thirty minutes east of Greenwich." It is permitted for the
       *     string to specify {@code GMT}, {@code UT}, or {@code UTC}
       *     redundantly-for example, {@code GMT-5} or {@code utc+0430}.
       * <li>The number is regarded as a year number if one of the
       *     following conditions is true:
       * <ul>
       *     <li>The number is equal to or greater than 70 and followed by a
       *         space, comma, slash, or end of string
       *     <li>The number is less than 70, and both a month and a day of
       *         the month have already been recognized</li>
       * </ul>
       *     If the recognized year number is less than 100, it is
       *     interpreted as an abbreviated year relative to a century of
       *     which dates are within 80 years before and 19 years after
       *     the time when the Date class is initialized.
       *     After adjusting the year number, 1900 is subtracted from
       *     it. For example, if the current year is 1999 then years in
       *     the range 19 to 99 are assumed to mean 1919 to 1999, while
       *     years from 0 to 18 are assumed to mean 2000 to 2018.  Note
       *     that this is slightly different from the interpretation of
       *     years less than 100 that is used in {@link java.text.SimpleDateFormat}.
       * <li>If the number is followed by a colon, it is regarded as an hour,
       *     unless an hour has already been recognized, in which case it is
       *     regarded as a minute.
       * <li>If the number is followed by a slash, it is regarded as a month
       *     (it is decreased by 1 to produce a number in the range {@code 0}
       *     to {@code 11}), unless a month has already been recognized, in
       *     which case it is regarded as a day of the month.
       * <li>If the number is followed by whitespace, a comma, a hyphen, or
       *     end of string, then if an hour has been recognized but not a
       *     minute, it is regarded as a minute; otherwise, if a minute has
       *     been recognized but not a second, it is regarded as a second;
       *     otherwise, it is regarded as a day of the month. </ul><p>
       * A consecutive sequence of letters is regarded as a word and treated
       * as follows:<ul>
       * <li>A word that matches {@code AM}, ignoring case, is ignored (but
       *     the parse fails if an hour has not been recognized or is less
       *     than {@code 1} or greater than {@code 12}).
       * <li>A word that matches {@code PM}, ignoring case, adds {@code 12}
       *     to the hour (but the parse fails if an hour has not been
       *     recognized or is less than {@code 1} or greater than {@code 12}).
       * <li>Any word that matches any prefix of {@code SUNDAY, MONDAY, TUESDAY,
       *     WEDNESDAY, THURSDAY, FRIDAY}, or {@code SATURDAY}, ignoring
       *     case, is ignored. For example, {@code sat, Friday, TUE}, and
       *     {@code Thurs} are ignored.
       * <li>Otherwise, any word that matches any prefix of {@code JANUARY,
       *     FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER,
       *     OCTOBER, NOVEMBER}, or {@code DECEMBER}, ignoring case, and
       *     considering them in the order given here, is recognized as
       *     specifying a month and is converted to a number ({@code 0} to
       *     {@code 11}). For example, {@code aug, Sept, april}, and
       *     {@code NOV} are recognized as months. So is {@code Ma}, which
       *     is recognized as {@code MARCH}, not {@code MAY}.
       * <li>Any word that matches {@code GMT, UT}, or {@code UTC}, ignoring
       *     case, is treated as referring to UTC.
       * <li>Any word that matches {@code EST, CST, MST}, or {@code PST},
       *     ignoring case, is recognized as referring to the time zone in
       *     North America that is five, six, seven, or eight hours west of
       *     Greenwich, respectively. Any word that matches {@code EDT, CDT,
       *     MDT}, or {@code PDT}, ignoring case, is recognized as
       *     referring to the same time zone, respectively, during daylight
       *     saving time.</ul><p>
       * Once the entire string s has been scanned, it is converted to a time
       * result in one of two ways. If a time zone or time-zone offset has been
       * recognized, then the year, month, day of month, hour, minute, and
       * second are interpreted in UTC and then the time-zone offset is
       * applied. Otherwise, the year, month, day of month, hour, minute, and
       * second are interpreted in the local time zone.
       *
       * @param   s   a string to be parsed as a date.
       * @return  the number of milliseconds since January 1, 1970, 00:00:00 GMT
       *          represented by the string argument.
       * @see     java.text.DateFormat
       * @deprecated As of JDK version 1.1,
       * replaced by {@code DateFormat.parse(String s)}.
       */
      @Deprecated
      public static long parse(String s) {
          int year = Integer.MIN_VALUE;
          int mon = -1;
          int mday = -1;
          int hour = -1;
          int min = -1;
          int sec = -1;
          int millis = -1;
          int c = -1;
          int i = 0;
          int n = -1;
          int wst = -1;
          int tzoffset = -1;
          int prevc = 0;
      syntax:
          {
              if (s == null)
                  break syntax;
              int limit = s.length();
              while (i < limit) {
                  c = s.charAt(i);
                  i++;
                  if (c <= ' ' || c == ',')
                      continue;
                  if (c == '(') { // skip comments
                      int depth = 1;
                      while (i < limit) {
                          c = s.charAt(i);
                          i++;
                          if (c == '(') depth++;
                          else if (c == ')')
                              if (--depth <= 0)
                                  break;
                      }
                      continue;
                  }
                  if ('0' <= c && c <= '9') {
                      n = c - '0';
                      while (i < limit && '0' <= (c = s.charAt(i)) && c <= '9') {
                          n = n * 10 + c - '0';
                          i++;
                      }
                      if (prevc == '+' || prevc == '-' && year != Integer.MIN_VALUE) {
                          // timezone offset
                          if (n < 24)
                              n = n * 60; // EG. "GMT-3"
                          else
                              n = n % 100 + n / 100 * 60; // eg "GMT-0430"
                          if (prevc == '+')   // plus means east of GMT
                              n = -n;
                          if (tzoffset != 0 && tzoffset != -1)
                              break syntax;
                          tzoffset = n;
                      } else if (n >= 70)
                          if (year != Integer.MIN_VALUE)
                              break syntax;
                          else if (c <= ' ' || c == ',' || c == '/' || i >= limit)
                              // year = n < 1900 ? n : n - 1900;
                              year = n;
                          else
                              break syntax;
                      else if (c == ':')
                          if (hour < 0)
                              hour = (byte) n;
                          else if (min < 0)
  