class LongToIntConsistentHash {
    protected static final int DEFAULT_REPLICAS = 128;
    protected TreeMap<Long,Integer> circle = new TreeMap<Long,Integer>();
    protected int replicasInstalledUpTo=-1; 
    protected int numReplicas; 

    public LongToIntConsistentHash() {
        this(DEFAULT_REPLICAS); 
    }
    
    public LongToIntConsistentHash(int numReplicas) {
        this.numReplicas = numReplicas;
        installReplicas(0);
        replicasInstalledUpTo=1;
    }

    /**
     * Install necessary replicas, if not already present.
     * @param upTo
     */
    public void installReplicasUpTo(int upTo) {
        if(replicasInstalledUpTo>upTo) {
            return;
        }
        for(;replicasInstalledUpTo<upTo;replicasInstalledUpTo++) {
            installReplicas(replicasInstalledUpTo);
        }
    }

    private void installReplicas(int bucket) {
        for(int i = 0; i < numReplicas; i++) {
            circle.put(
                    replicaLocation(bucket,i),
                    bucket);
        }
    }
    
//    SecureRandom rand = new SecureRandom(); 
    protected long replicaLocation(int bucketNumber, int replicaNumber) {
//      return rand.nextLong();
//      return RandomUtils.nextLong();
//      return ArchiveUtils.doubleMurmur(string.getBytes());
//      return (new JenkinsHash()).hash(string.getBytes());
       return FPGenerator.std64.fp(bucketNumber+"."+replicaNumber);
    }
    
    protected long hash(CharSequence cs) {
//      return ArchiveUtils.doubleMurmur(string.getBytes());
//      return (new JenkinsHash()).hash(string.getBytes());
       return FPGenerator.std64.fp(cs);
    }

    /**
     * Return the proper integer bucket-number for the given long hash,
     * up to the given integer boundary (exclusive). 
     * 
     * @param longHash
     * @param upTo
     */
    public int bucketFor(long longHash, int upTo) {<FILL_FUNCTION_BODY>}

    /**
     * Convenience alternative which creates longHash from CharSequence
     */
    public int bucketFor(CharSequence cs, int upTo) {
        return bucketFor(hash(cs), upTo);
    }

    public int bucketFor(char[] chars, int upTo) {
        return bucketFor(hash(new String(chars)), upTo);
    }
}

        installReplicasUpTo(upTo); 
        
        NavigableMap<Long, Integer> tailMap = circle.tailMap(longHash, true);
        Map.Entry<Long,Integer> match = null;
        for(Map.Entry<Long,Integer> candidate : tailMap.entrySet()) {
            if(candidate.getValue() < upTo) {
                match = candidate; 
                break;
            }
        }
        
        if (match == null) {
            return bucketFor(Long.MIN_VALUE,upTo);
        } 
        return match.getValue();
    
<no_super_class>