Returns the smaller of some timecodes

@param timecodes
some timecodes

@return
180830
public static Timecode min(final Timecode... timecodes)
	{
		Timecode min = null;

		for (Timecode timecode : timecodes)
			if (min == null || ge(min, timecode))
				min = timecode;

		return min;
	}
58431
public static Deadline soonest(Deadline... deadlines)
	{
		Deadline min = null;

		if (deadlines != null)
			for (Deadline deadline : deadlines)
			{
				if (deadline != null)
				{
					if (min == null)
						min = deadline;
					else if (deadline.getTimeLeft() < min.getTimeLeft())
					{
						min = deadline;
					}
				}
			}

		return min;
	}
818896
public long toMilliseconds() {
        final Date now = new Date();
        return TimeCategory.minus(plus(now), now).toMilliseconds();
    }
482103
public static <T> T min(Iterator<T> self) {
        return min((Iterable<T>)toList(self));
    }
1006722
@Deprecated
  public static Pattern some(int min, int max, CharPredicate predicate) {
    return times(min, max, predicate);
  }
371731
function( times ) {

		function compareTime( i, j ) {

			return times[ i ] - times[ j ];

		}

		var n = times.length;
		var result = new Array( n );
		for ( var i = 0; i !== n; ++ i ) result[ i ] = i;

		result.sort( compareTime );

		return result;

	}
851669
public CurrencyQueryBuilder setNumericCodes(int... codes) {
        return set(CurrencyQuery.KEY_QUERY_NUMERIC_CODES,
                Arrays.stream(codes).boxed().collect(Collectors.toList()));
    }
930358
public static BigInteger minimum(BigInteger... values)
    {
        int len = values.length;
        if (len == 1)
        {
            if (values[0] == null)
            {
                throw new IllegalArgumentException("Cannot passed null BigInteger entry to minimum()");
            }
            return values[0];
        }
        BigInteger current = values[0];

        for (int i=1; i < len; i++)
        {
            if (values[i] == null)
            {
                throw new IllegalArgumentException("Cannot passed null BigInteger entry to minimum()");
            }
            current = values[i].min(current);
        }

        return current;
    }
685023
public boolean overlaps(TimecodeRange that)
	{
		if (this.within(that.getStart()) || this.within(that.getEnd()))
		{
			return true; // we contain one of their timecodes
		}
		else if (that.within(this.getStart()) || that.within(this.getEnd()))
		{
			return true; // they contain one of our timecodes
		}
		else
		{
			return false;
		}
	}
1204773
public static <T> T min(T[] items) {
        return min((Iterable<T>)Arrays.asList(items));
    }
108038
public static Predicate<? super Throwable> statusCode(int... codes) {
        return t -> t instanceof ClientV2Exception &&
            Arrays.stream(codes).anyMatch(candidate -> ((ClientV2Exception) t).getCode().equals(candidate));
    }
671476
private static long[] getFields(final Timecode tc)
	{
		// Flip the sign on all fields for negative timecodes
		final int negativiser = tc.isNegative() ? -1 : 1;

		return new long[]{negativiser * tc.getDaysPart(),
		                  negativiser * tc.getHoursPart(),
		                  negativiser * tc.getMinutesPart(),
		                  negativiser * tc.getSecondsPart(),
		                  negativiser * tc.getFramesPartAsMicroseconds()};
	}
301888
function timeCode(seconds, delim = ':') {
    // const h = Math.floor(seconds / 3600);
    // const m = Math.floor((seconds % 3600) / 60);
    const m = Math.floor(seconds / 60);
    const s = Math.floor((seconds % 3600) % 60);
    // const hr = (h < 10 ? '0' + h + delim : h + delim);
    const mn = (m < 10 ? '0' + m : m) + delim;
    const sc = (s < 10 ? '0' + s : s);
    // return hr + mn + sc;
    return mn + sc;
}
1076746
public static long minimum(long... values)
    {
        int len = values.length;
        long current = values[0];

        for (int i=1; i < len; i++)
        {
            current = Math.min(values[i], current);
        }

        return current;
    }
1362601
private void cacheCodes() {
        Set<ProcCode> set = new HashSet<ProcCode>();

        if (parent != null) {
            set.addAll(Arrays.asList(parent.getCodes()));
        }

        if (scopeCodes != null) {
            set.addAll(scopeCodes);
        }

        cachedCodes = set.toArray(new ProcCode[set.size()]);
        Arrays.sort(
                cachedCodes,
                new Comparator<ProcCode>() {
                    public int compare(ProcCode code1, ProcCode code2) {
                        return code2.compareTo(code1);
                    }
                }
        );

        for (ProcCode code : cachedCodes) {
            hasCrazyCode = hasCrazyCode || !code.startsWithConstant();
            hasCheck = hasCheck || code.containsCheck();
        }
    }
151211
public final Parser<List<T>> times(int min, int max) {
    Checks.checkMinMax(min, max);
    return new RepeatTimesParser<T>(this, min, max);
  }
856714
public static long min(LongTuple t)
    {
        return LongTupleFunctions.reduce(
            t, Long.MAX_VALUE, Math::min);
    }