import java.io.*;
import java.util.*;

/*
Нити и байты
*/

public class Solution {
    public static Map<String, List<Integer>> resultMap = new HashMap<>();

    public static void main(String[] args) {

//        // читаем имена файлов и записываем в resultMap
//        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
//            String fileName;
//
//            while (!(fileName = reader.readLine()).equals("exit")) {
//                resultMap.put(fileName, 0); // пока что записываем только имена
//            }
//        } catch (IOException ignored) {
//
//        }
        resultMap = new HashMap<>() {
            {
                put("0", new ArrayList<>());
                put("1", new ArrayList<>());
                put("2", new ArrayList<>());
                put("3", new ArrayList<>());
            }
        };

        byte[][] mocks = {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 9},
                {10, 11, 12},
                {13, 14, 15}
        };

        Thread[] threads = new Thread[5];
        // запускаем нити
        for (int mockIndex = 0; mockIndex < 3; mockIndex++) {
            threads[mockIndex] = new ReadThread(String.valueOf(mockIndex), mocks[mockIndex]);
            threads[mockIndex].start();
        }
        threads[3] = new ReadThread("3", mocks[3]);
        threads[4] = new ReadThread("3", mocks[4]);
        threads[3].start();
        threads[4].start();
        try {
            for (Thread thread :
                    threads) {
                thread.join();
            }
        } catch (InterruptedException ignored) {

        }

        System.out.println(resultMap);


    }

    public static class ReadThread extends Thread {
        String fileName;
        byte[] mock;

        public ReadThread(String fileName, byte[] mock) {
            this.fileName = fileName;
            this.mock = mock;
        }

        // implement file reading here - реализуйте чтение из файла тут
        private byte[] fileBytes;

        @Override
        public void run() {
            // читаем файл в массив байт fileBytes
            fileBytes = new byte[]{};
            try (InputStream inputStream = new ByteArrayInputStream(mock)) {
                ByteArrayOutputStream byteArrStream = new ByteArrayOutputStream();

                byte[] buf = new byte[1024];
                int count;

                while ((count = inputStream.read(buf)) != -1) {
                    byteArrStream.write(buf, 0, count);
                }

                fileBytes = byteArrStream.toByteArray();
            } catch (FileNotFoundException e) {

            } catch (IOException e) {

            }

            // создаем словарь byteEntries (ключи - байты из файла, значения - количество вхождений соответствующего байта в файл)
            // и заполняем его байтами из файла
            Map<Byte, Integer> byteEntries = new HashMap<>();
            for (byte b : fileBytes) {
                byteEntries.put(b, 0); // пока что заполняем только ключи (байты)
            }

            // для каждого байта вбиваем соотвутствующее ему количество вхождений в файл
            for (Map.Entry<Byte, Integer> pair : byteEntries.entrySet()) {
                byte b = pair.getKey();
                int numberOfEntries = getNumberOfEntries(b);
                byteEntries.put(b, numberOfEntries);
            }

            int maxValue = Collections.max(byteEntries.values()); // ищем максимальное значение в множестве количеств вхождений байтов в файл (самую большую частоту повторения)
            int mostFrequentByte = (int) getKeyByValue(byteEntries, maxValue); // ищем соответствующий ему (самый часто повторяемый) байт

            // окончательно заполняем resultMap
//            resultMap.put(fileName, mostFrequentByte);
            synchronized (resultMap) {
                resultMap.get(fileName).add(mostFrequentByte);
            }
        }

        // возвращает количество вхождений в файл байта, переданного параметром
        private int getNumberOfEntries(byte byteFromFile) {
            int numberOfEntries = 0;

            for (byte b : fileBytes) {
                if (b == byteFromFile) {
                    numberOfEntries++;
                }
            }

            return numberOfEntries;
        }

        // для данной map возвращает ключ (key) по соответствующему ему значению (value)
        // в общем случае ключей с одинаковым значением может быть больше одного
        // не юзать больше этот метод
        // однако в данной задаче для более менее большого файла маловероятно, что самых часто встречаемых байтов будет больше одного
        private <K, V> K getKeyByValue(Map<K, V> map, V value) {
            K key = null;

            for (Map.Entry<K, V> pair : map.entrySet()) {
                if (pair.getValue().equals(value)) {
                    key = pair.getKey();
                }
            }

            return key;
        }
    }
}