import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import jdk.internal.vm.Continuation;
import jdk.internal.vm.ContinuationScope;
import sun.misc.Unsafe;

// java --enable-preview --add-opens java.base/jdk.internal.vm=ALL-UNNAMED Prime3
@SuppressWarnings("deprecation")
public class Prime3 {
	private static final ContinuationScope cs = new ContinuationScope("VirtualThreads");
	private static final ArrayList<Continuation> readyStack = new ArrayList<>(10000);
	private static final Unsafe U;
	private static final long CONT_OFFSET;
	private static final MethodHandle DO_YIELD;
	private static final MethodHandle ENTER_SPECIAL;

	static {
		try {
			var theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe");
			theUnsafeField.setAccessible(true);
			U = (Unsafe)theUnsafeField.get(null);
			long OVERRIDE_OFFSET;
			for (long i = 8; ; i++) {
				if (U.getBoolean(theUnsafeField, i)) {
					theUnsafeField.setAccessible(false);
					if (!U.getBoolean(theUnsafeField, i)) {
						OVERRIDE_OFFSET = i;
						break;
					}
					theUnsafeField.setAccessible(true);
				}
				if (i == 32) // should be enough
					throw new UnsupportedOperationException(System.getProperty("java.version"));
			}

			var f = Thread.class.getDeclaredField("cont");
			U.putBoolean(f, OVERRIDE_OFFSET, true); // f.setAccessible(true);
			CONT_OFFSET = U.objectFieldOffset(f);
			var m = Continuation.class.getDeclaredMethod("doYield");
			U.putBoolean(m, OVERRIDE_OFFSET, true); // m.setAccessible(true);
			DO_YIELD = MethodHandles.lookup().unreflect(m);
			m = Continuation.class.getDeclaredMethod("enterSpecial", Continuation.class, boolean.class, boolean.class);
			U.putBoolean(m, OVERRIDE_OFFSET, true); // m.setAccessible(true);
			ENTER_SPECIAL = MethodHandles.lookup().unreflect(m);
		} catch (ReflectiveOperationException e) {
			throw new RuntimeException(e);
		}
	}

	static void loop() {
		try {
			for (int n; (n = readyStack.size()) > 0; )
				ENTER_SPECIAL.invokeExact(readyStack.remove(n - 1), true, false);
		} catch (Throwable e) {
			throw new RuntimeException(e);
		}
	}

	static void resume(Continuation c) {
		if (c.isDone())
			throw new IllegalStateException("Continuation terminated");
		readyStack.add(c);
	}

	static void go(Runnable r) {
		new Continuation(cs, r).run();
	}

	static void pause(Deque<Continuation> queue) {
		var c = (Continuation)U.getObject(Thread.currentThread(), CONT_OFFSET);
		queue.addLast(c);
		try {
			@SuppressWarnings("unused")
			var __ = (int)DO_YIELD.invokeExact();
			U.storeFence(); // needed to prevent certain transformations by the compiler
		} catch (Throwable e) {
			throw new RuntimeException(e);
		} finally {
			U.putObject(Thread.currentThread(), CONT_OFFSET, c);
		}
	}

	static class IntChan {
		private final ArrayDeque<Continuation> waitQueue = new ArrayDeque<>();
		private int value;
		private boolean hasValue;

		void put(int v) {
			if (hasValue)
				pause(waitQueue);
			value = v;
			hasValue = true;
			var c = waitQueue.pollFirst();
			if (c != null)
				resume(c);
		}

		int get() {
			if (!hasValue)
				pause(waitQueue);
			hasValue = false;
			var c = waitQueue.pollFirst();
			if (c != null)
				resume(c);
			return value;
		}
	}

	private static void generate(IntChan ch) {
		//noinspection InfiniteLoopStatement
		for (int i = 2; ; i++)
			ch.put(i);
	}

	private static void filter(IntChan in, IntChan out, int prime) {
		//noinspection InfiniteLoopStatement
		for (; ; ) {
			var i = in.get();
			if (i % prime != 0)
				out.put(i);
		}
	}

	public static void main(String[] args) {
		var count = args.length > 0 ? Integer.parseInt(args[0]) : 10000;
		var ch = new IntChan();
		go(() -> generate(ch));
		go(() -> {
			var ch0 = ch;
			for (int i = 0; ; ) {
				var prime = ch0.get();
				if (++i == count) {
					System.out.println(prime);
					System.exit(0);
				}
				var ch1 = ch0;
				var ch2 = new IntChan();
				go(() -> filter(ch1, ch2, prime));
				ch0 = ch2;
			}
		});
		loop();
	}
}