Random

import java.io.*;
import java.time.LocalTime;
import java.util.Arrays;
import java.util.concurrent.atomic.AtomicInteger;

final class Main {
    private static final class BadRandom {
        private static final class ParamGenerator {
            private static final int rand() {
                return (LocalTime.now().getNano()
                        * LocalTime.now().getHour()
                        + LocalTime.now().getSecond())
                        % LocalTime.now().getNano();
            }
        }

        private static AtomicInteger cnt = new AtomicInteger(0);
        private static AtomicInteger a = new AtomicInteger(ParamGenerator.rand());
        private static AtomicInteger c = new AtomicInteger(ParamGenerator.rand());
        private static AtomicInteger m = new AtomicInteger(ParamGenerator.rand());
        private static int last = ParamGenerator.rand();

        public static final void update() {
            cnt.updateAndGet(x -> {
                final var res = (x + 1) % 100;

                if (res == 0) {
                    c.set(ParamGenerator.rand());
                    m.set(ParamGenerator.rand());
                }

                return res;
            });
        }

        private static final int rand() {
            last = (a.get() * last + c.get()) % m.get();
            update();
            return last;
        }
    }

    public static final void main(final String[] args) throws IOException {
        try (final var reader = new BufferedReader(new InputStreamReader(System.in))) {
            final var writer = System.out;

            writer.print("n: ");
            final var n = Integer.parseInt(reader.readLine());

            writer.print("m: ");
            final var m = Integer.parseInt(reader.readLine());

            final var arr = new int[n];

            final var numsInThreads = new int[m];
            final var ost = n % m;
            Arrays.fill(numsInThreads, n / m);
            for (int i = 0; i < ost; i++) numsInThreads[i]++;

            int cur = 0;

            final var threads = new Thread[m];

            for (int p = 0; p < m; p++) {
                final var _cur = cur;
                final var finalP = p;

                threads[p] = new Thread(() -> {
                    final var f = _cur + numsInThreads[finalP];
                    for (int i = _cur; i < f; i++) arr[i] = BadRandom.rand();
                });

                threads[p].start();
                cur += numsInThreads[p];
            }

            Arrays.stream(threads).forEach(thread -> {
                try { thread.join(); } catch (final Exception e) { e.printStackTrace(); }
            });

            Arrays.stream(arr).forEach(writer::println);
        }
    }
}