private static final int S_MAXLEN_INT = String.valueOf(Integer.MAX_VALUE).length();
436328
@Nonnull
    public Number toJavaLangNumber() {
        int flags = getFlags();
        if ((flags & F_DOUBLE) != 0)
            return doubleValue();
        else if ((flags & F_FLOAT) != 0)
            return floatValue();
        else if ((flags & (F_LONG | F_LONGLONG)) != 0)
            return longValue();
        else if ((flags & F_INT) != 0)
            return intValue();
        else if (getFractionalPart() != null)
            return doubleValue();	// .1 is a double in Java.
        else if (getExponent() != null)
            return doubleValue();
        else {
            // This is an attempt to avoid overflowing on over-long integers.
            // However, now we just overflow on over-long longs.
            // We should really use BigInteger.
            long value = longValue();
            if (value <= Integer.MAX_VALUE && value >= Integer.MIN_VALUE)
                return (int) value;
            return value;
        }
    }
934426
int getLongestChainLength() {
		int maxLen = 0;

		for (Entry<?, ?> entry : table) {
			int thisLen = 0;
			while (entry != null) {
				thisLen++;
				entry = entry.next;
			}
			maxLen = Math.max(maxLen, thisLen);
		}

		return maxLen;
	}
714853
public static int getMaxValueIndex (int[] values)
    {
        if (values == null || values.length == 0) {
            return -1;
        }

        int idx = 0;
        int max = values[idx];
        for (int ii = 1; ii < values.length; ii++) {
            if (values[ii] > max) {
                max = values[ii];
                idx = ii;
            }
        }
        return idx;
    }
303318
public function getMaxLength()
    {
        if ($this->isString() && isset($this->methodParams[0])) {
            return intval($this->methodParams[0]);
        }

        return null;
    }
660250
protected int max(int[] v)
	{
		int x = 0;
		for (int i : v)
		{
			if (i > x) x = i;
		}
		return x;
	}
895970
private int getIntValue(String str, int defaultValue) {

        try {
            int intValue = Integer.parseInt(str);
            return (intValue > 0) ? intValue : defaultValue;
        } catch (NumberFormatException e) {
            // intentionally left blank
        }
        return defaultValue;
    }
478524
public int getMaxlength() {
        return (java.lang.Integer) getStateHelper().eval(PropertyKeys.maxlength, Integer.MIN_VALUE);

    }
493062
private static final void writeVarLengthInt(DataOutput out, int value) throws IOException {
		while (value >= MAX_BIT) {
			out.write(value | MAX_BIT);
			value >>= 7;
		}
		out.write(value);
	}
829817
public void init(long maxValue, int machineNum) {
		this.size = maxValue;
		switch (machineNum) {
		case BitMap.MACHINE32:
			bm = new IntMap((int) (size / machineNum));
			break;
		case BitMap.MACHINE64:
			bm = new LongMap((int) (size / machineNum));
			break;
		default:
			throw new RuntimeException("Error Machine number!");
		}
	}
295174
public void setMax(java.lang.Object _max) {
		getStateHelper().put(PropertyKeys.max, _max);
	}
677964
long string2Long(CharSequence cs, int readed) {
		if (cs.length() > 16) {
			throw new JsonParseException("Number string is too long.", readed);
		}
		long n = 0;
		for (int i = 0; i < cs.length(); i++) {
			n = n * 10 + (cs.charAt(i) - '0');
			if (n > MAX_SAFE_INTEGER) {
				throw new JsonParseException("Exceeded maximum value: "
						+ MAX_SAFE_INTEGER, readed);
			}
		}
		return n;
	}
496856
function intmax( type ) {
	if ( !arguments.length ) {
		return TYPES.int32;
	}
	if ( !isString( type ) ) {
		throw new TypeError( 'intmax()::invalid input argument. Must provide an input string primitive. Value: `' + type + '`.' );
	}
	if ( !TYPES.hasOwnProperty( type ) ) {
		throw new Error( 'intmax()::invalid input argument. Unrecognized integer type. Must be one of the following: \"' + Object.keys( TYPES ).join( '\", \"' ) + '\". Value: `' + type + '`.' );
	}
	return TYPES[ type ];
}
213227
private String LPad(String inStr, int maxLen) {
        if (inStr.length() >= maxLen) return inStr.toUpperCase();
        String zeroes = PADCHARS.substring(0, maxLen - inStr.length());
        String retVal = zeroes + inStr;
        return retVal.toUpperCase();
    }
1250111
private static Integer integerValueOf(String value) {
		try {
			return Integer.valueOf(value);
		} catch (NumberFormatException e) {
			throw new CannotParseException(40, value);
		}
	}
221820
private static int maxLength(List<String> coll) {
		int max = 0;
		for (String e : coll) {
			int length = e.length();
			if (length > max) {
				max = length;
			}
		}
		return max;
	}
1372100
private final void ensureCapacity(int len) {
        if (value.length < len) {
            value = new int[len];
            offset = 0;
            intLen = len;
        }
    }
899612
public static int max( byte []array , int offset , int length ) {
		int max = -Integer.MAX_VALUE;
		for (int i = 0; i < length; i++) {
			int tmp = array[offset+i];
			if( tmp > max ) {
				max = tmp;
			}
		}
		return max;
	}