// Path: src/main/java/edu/berkeley/nlp/lm/util/MurmurHash.java
// public final class MurmurHash
// {
// 
// 	/**
// 	 * Generates 32 bit hash from byte array of the given length and seed.
// 	 * 
// 	 * @param data
// 	 *            int array to hash
// 	 * @param length
// 	 *            length of the array to hash
// 	 * @param seed
// 	 *            initial seed value
// 	 * @return 32 bit hash of the given array
// 	 */
// 	public static int hash32(final int[] data, int startPos, int endPos, int seed) {
// 		// 'm' and 'r' are mixing constants generated offline.
// 		// They're not really 'magic', they just happen to work well.
// 		final int m = 0x5bd1e995;
// 		final int r = 24;
// 		final int length = endPos - startPos;
// 		// Initialize the hash to a random value
// 		int h = seed ^ length;
// 
// 		for (int i = startPos; i < endPos; i++) {
// 			int k = data[i];
// 			k *= m;
// 			k ^= k >>> r;
// 			k *= m;
// 			h *= m;
// 			h ^= k;
// 		}
// 
// 		h ^= h >>> 13;
// 		h *= m;
// 		h ^= h >>> 15;
// 
// 		return h;
// 	}
// 
// 	public static int hash32(final int[] data, int startPos, int endPos) {
// 		return hash32(data, startPos, endPos, 0x9747b28c);
// 	}
// 
// 	public static long hashOneLong(final long k_, final int seed) {
// 		long k = k_;
// 		final long m = 0xc6a4a7935bd1e995L;
// 		final int r = 47;
// 
// 		long h = (seed & 0xffffffffl) ^ (1 * m);
// 
// 		k *= m;
// 		k ^= k >>> r;
// 		k *= m;
// 
// 		h ^= k;
// 		h *= m;
// 
// 		h ^= h >>> r;
// 		h *= m;
// 		h ^= h >>> r;
// 
// 		return h;
// 	}
// 
// 	public static long hashThreeLongs(final long k1, final long k2, final long k3) {
// 
// 		final int seed = 0x9747b28c;
// 		final long m = 0xc6a4a7935bd1e995L;
// 		final int r = 47;
// 
// 		long h = (seed & 0xffffffffl) ^ (1 * m);
// 		for (int i = 0; i <= 2; ++i) {
// 			long k = -1;
// 			switch (i) {
// 				case 0:
// 					k = k1;
// 					break;
// 				case 1:
// 					k = k2;
// 					break;
// 				case 2:
// 					k = k3;
// 					break;
// 				default:
// 					assert false;
// 			}
// 			k *= m;
// 			k ^= k >>> r;
// 			k *= m;
// 
// 			h ^= k;
// 			h *= m;
// 		}
// 
// 		h ^= h >>> r;
// 		h *= m;
// 		h ^= h >>> r;
// 
// 		return h;
// 	}
// 
// }


import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import edu.berkeley.nlp.lm.util.MurmurHash;
	 */
	private boolean putHelp(long k, int v, long[] keyArray, int[] valueArray) {
		checkNotImmutable();
		assert v >= 0;
		int pos = find(k, true, keyArray, valueArray);
		//		int pos = getInitialPos(k, keyArray);
		//		long currKey = keyArray[pos];
		//		while (currKey != EMPTY_KEY && currKey != k) {
		//			pos++;
		//			if (pos == keyArray.length) pos = 0;
		//			currKey = keyArray[pos];
		//		}
		//
		boolean wasEmpty = valueArray[pos] == EMPTY_VAL;
		valueArray[pos] = v;
		if (wasEmpty) {
			size++;
			keyArray[pos] = k;
			return true;
		}
		return false;
	}

	/**
	 * @param k
	 * @param keyArray
	 * @return
	 */
	private static int getInitialPos(final long k, final int length) {
		if (length < 0) return (int) k;
// Path: src/main/java/edu/berkeley/nlp/lm/util/MurmurHash.java
// public final class MurmurHash
// {
// 
// 	/**
// 	 * Generates 32 bit hash from byte array of the given length and seed.
// 	 * 
// 	 * @param data
// 	 *            int array to hash
// 	 * @param length
// 	 *            length of the array to hash
// 	 * @param seed
// 	 *            initial seed value
// 	 * @return 32 bit hash of the given array
// 	 */
// 	public static int hash32(final int[] data, int startPos, int endPos, int seed) {
// 		// 'm' and 'r' are mixing constants generated offline.
// 		// They're not really 'magic', they just happen to work well.
// 		final int m = 0x5bd1e995;
// 		final int r = 24;
// 		final int length = endPos - startPos;
// 		// Initialize the hash to a random value
// 		int h = seed ^ length;
// 
// 		for (int i = startPos; i < endPos; i++) {
// 			int k = data[i];
// 			k *= m;
// 			k ^= k >>> r;
// 			k *= m;
// 			h *= m;
// 			h ^= k;
// 		}
// 
// 		h ^= h >>> 13;
// 		h *= m;
// 		h ^= h >>> 15;
// 
// 		return h;
// 	}
// 
// 	public static int hash32(final int[] data, int startPos, int endPos) {
// 		return hash32(data, startPos, endPos, 0x9747b28c);
// 	}
// 
// 	public static long hashOneLong(final long k_, final int seed) {
// 		long k = k_;
// 		final long m = 0xc6a4a7935bd1e995L;
// 		final int r = 47;
// 
// 		long h = (seed & 0xffffffffl) ^ (1 * m);
// 
// 		k *= m;
// 		k ^= k >>> r;
// 		k *= m;
// 
// 		h ^= k;
// 		h *= m;
// 
// 		h ^= h >>> r;
// 		h *= m;
// 		h ^= h >>> r;
// 
// 		return h;
// 	}
// 
// 	public static long hashThreeLongs(final long k1, final long k2, final long k3) {
// 
// 		final int seed = 0x9747b28c;
// 		final long m = 0xc6a4a7935bd1e995L;
// 		final int r = 47;
// 
// 		long h = (seed & 0xffffffffl) ^ (1 * m);
// 		for (int i = 0; i <= 2; ++i) {
// 			long k = -1;
// 			switch (i) {
// 				case 0:
// 					k = k1;
// 					break;
// 				case 1:
// 					k = k2;
// 					break;
// 				case 2:
// 					k = k3;
// 					break;
// 				default:
// 					assert false;
// 			}
// 			k *= m;
// 			k ^= k >>> r;
// 			k *= m;
// 
// 			h ^= k;
// 			h *= m;
// 		}
// 
// 		h ^= h >>> r;
// 		h *= m;
// 		h ^= h >>> r;
// 
// 		return h;
// 	}
// 
// }


// Path: src/main/java/edu/berkeley/nlp/lm/collections/LongToIntHashMap.java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import edu.berkeley.nlp.lm.util.MurmurHash;

	 */
	private boolean putHelp(long k, int v, long[] keyArray, int[] valueArray) {
		checkNotImmutable();
		assert v >= 0;
		int pos = find(k, true, keyArray, valueArray);
		//		int pos = getInitialPos(k, keyArray);
		//		long currKey = keyArray[pos];
		//		while (currKey != EMPTY_KEY && currKey != k) {
		//			pos++;
		//			if (pos == keyArray.length) pos = 0;
		//			currKey = keyArray[pos];
		//		}
		//
		boolean wasEmpty = valueArray[pos] == EMPTY_VAL;
		valueArray[pos] = v;
		if (wasEmpty) {
			size++;
			keyArray[pos] = k;
			return true;
		}
		return false;
	}

	/**
	 * @param k
	 * @param keyArray
	 * @return
	 */
	private static int getInitialPos(final long k, final int length) {
		if (length < 0) return (int) k;
		long hash = MurmurHash.hashOneLong(k, 31);