@Override
    public Binary get(Object key) {
        if (!(key instanceof Binary))
            return null;
        
        final Binary bKey = (Binary) key;
        final byte[] keyData = bKey.getValue();
        final int keySize = keyData.length;
        
        final int hash = Math.abs(hashFunction.apply(keyData));
        final long offset = hash % partitionCount;
        
        // This is the location of the partition on which the entry key belongs
        long locationAddress = unsafe.getAddress(partitionAddress + (offset * addressSize));

        // Skip if unallocated
        if (locationAddress == 0)
            return null;
        
        // Read how many entries we expect in this partition
        int entryCount = unsafe.getInt(locationAddress);
        
        // Move pointer past size int
        locationAddress += Integer.BYTES;
        
        for (long locationOffset = 0; locationOffset < entryCount; locationOffset++) {
            // Address of key within partition
            long keyAddress = unsafe.getAddress(locationAddress + (locationOffset * addressSize * 2));
            
            // Get size of key
            int size = unsafe.getInt(keyAddress);
            
            // If size of this key is different than the one
            // we're looking for, continue..
            if (size != keySize)
                continue;
            
            // Move pointer past size int
            keyAddress += Integer.BYTES;
            
            // Scan each byte to check for differences
            boolean isEqual = true;
            for (int keyOffset = 0; keyOffset < keySize; keyOffset++) {
                if (keyData[keyOffset] != unsafe.getByte(keyAddress + keyOffset)) {
                    isEqual = false;
                    break;
                }
            }
            
            // Check if we found the key
            if (isEqual) {
                long valueAddress = unsafe.getAddress(locationAddress + (locationOffset * addressSize * 2) + addressSize);
                
                // Check if this is a null value
                if (valueAddress == 0)
                    return null;
                
                int valueSize = unsafe.getInt(valueAddress);
                
                byte[] valueData = new byte[valueSize];
                
                // Move pointer past size int
                valueAddress += Integer.BYTES;
                
                for (int valueOffset = 0; valueOffset < valueSize; valueOffset++) {
                    valueData[valueOffset] = unsafe.getByte(valueAddress + valueOffset);
                }
                
                return new Binary(valueData);
            }
        }
        
        return null;
    }