public List<byte[]> getMulti(byte[] key) {
        if (this.hashFile == null) {
            throw new IllegalStateException(
                    "get() not allowed when HashFile is closed()");
        }

        long currentHashKey = Calculations.computeLongHash(key);

        int slot = Calculations.getBucket(currentHashKey,
                HashFile.this.bucketPower) * 2;

        long currentHashTableBasePosition = hashTableOffsets.get(slot);
        long currentHashTableSize = hashTableOffsets.get(slot + 1);

        if (currentHashTableSize == 0) {
            return Collections.<byte[]> emptyList();
        }

        ByteBuffer tableBytes = ByteBuffer
                .allocate(Calculations.LONG_POINTER_SIZE
                        * ((int) currentHashTableSize));
        LongBuffer table = tableBytes.asLongBuffer();

        List<byte[]> toReturn = new ArrayList<byte[]>();

        int probe = (int) (Math.abs(currentHashKey) % currentHashTableSize);

        try {
            synchronized (hashFile) {
                hashFile.seek(currentHashTableBasePosition);
                hashFile.readFully(tableBytes.array());
            }

            long currentFindOperationIndex = 0;

            while (currentFindOperationIndex < currentHashTableSize) {
                int probeSlot = 2 * probe;
                long probedHashCode = table.get(probeSlot);
                long probedPosition = table.get(probeSlot + 1);

                if (probedPosition == 0) {
                    continue;
                }

                currentFindOperationIndex += 1;
                probe += 1;

                if (probe >= currentHashTableSize) {
                    probe = 0;
                }

                if (probedHashCode != currentHashKey) {
                    continue;
                }

                synchronized (hashFile) {
                    hashFile.seek(probedPosition);
                    int keyLength = hashFile.readInt();

                    if (keyLength != key.length) {
                        continue;
                    }

                    int dataLength = hashFile.readInt();

                    byte[] probedKey = new byte[keyLength];
                    hashFile.readFully(probedKey);

                    if (!Arrays.equals(key, probedKey)) {
                        continue;
                    }

                    byte[] data = new byte[dataLength];
                    hashFile.readFully(data);
                    toReturn.add(data);
                }
            }
        } catch (IOException e) {
            throw new RuntimeException("Error while finding key: "
                    + e.getMessage(), e);
        }

        return toReturn;
    }