// VIM_TEST_SETUP let g:java_highlight_functions = 'style'
// VIM_TEST_SETUP let g:java_highlight_generics = 1
// VIM_TEST_SETUP set encoding=utf-8 termencoding=utf-8
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

abstract class StyleMethodsTests
{
	// TYPES.
	record Τʬ<α>(α a) { }

	enum E
	{
		A("a"), B("b"), C("c"), D("d"),
		E("e"), F("f"), G("g"), H("h");
		final String s;
		private E(String s) { this.s = s; }
	}

	@Target({ElementType.METHOD, ElementType.CONSTRUCTOR})
	@java.lang.annotation.Repeatable(Tɐggablɘs.class)
	@interface Tɐggablɘ
	{
		String[] value() default "";
	}

	@Target({ElementType.METHOD, ElementType.CONSTRUCTOR})
	@interface Tɐggablɘs
	{
		Tɐggablɘ[] value();
	}

	interface Stylable<Α>
	{
		default void ascii$0_() { }
		default Α μʭʭ$0_() { return null; }
	}

	// FIELDS.
	private static final Class<?> CLASS_LOCK = classLock();

	private final Object instanceLock = new Object();

	// CONSTRUCTORS.
	@Tɐggablɘ @Tɐggablɘ protected StyleMethodsTests() { }
	<T extends Comparable<T>> StyleMethodsTests(T t, Void v) { }
	private <T extends Comparable<T>> StyleMethodsTests(T t) { }

	// METHODS.
	@Tɐggablɘ @Tɐggablɘ abstract void ascii$0_(////////////////
								);
	@Tɐggablɘ @Tɐggablɘ abstract <α, β> Τʬ<α> μʭʭ$0_(
				@SuppressWarnings("bespoke") β b);

	@Tɐggablɘ private native void ascii$1_(/*////////////*/);
	@Tɐggablɘ private native <α, β> Τʬ<α>[] μʭʭ$1_(
			java.util.function.Function<β, Τʬ<α>[]> ƒ);

	void Ascii$2_() { }
	<T, U extends Stylable<T>> void Μʭʭ$2_(U u) { }

	static final native synchronized void ascii$98_();
	static final native synchronized <α, β> Τʬ<α>[][] μʭʭ$98_(
			java.util.function.Function<β, Τʬ<α>[][]> ƒ);

	@SuppressWarnings("strictfp")
	protected static final synchronized strictfp void ascii$99_()
	{ ascii$98_(); }

	@SuppressWarnings("strictfp") protected
	static final synchronized strictfp <α, β> Τʬ<α>[] μʭʭ$99_(
			java.util.function.Function<β, Τʬ<α>[][]> ƒ)
	{
		return
	StyleMethodsTests.<α, β>μʭʭ$98_(ƒ)[0];
	}

	public static Class<?> classLock() { return StyleMethodsTests.class; }

	public <E extends Comparable<? super E>> java.util.List<E> filter(
			java.util.function.Predicate<? super E> filter,
			java.util.List<? extends E> cs)
	{
		return cs.stream().filter(filter)
			.collect(java.util.stream.Collectors.toUnmodifiableList());
	}

	@Override @SuppressWarnings("cast")
	public String toString() { return (String) "StyleMethodsTests"; }
}

class StyleAlias<T>
{
	final T name; StyleAlias(T name)	{ this.name = name; }

	class Builder
	{
		final java.util.stream.Stream.Builder<T> builder =
			java.util.stream.Stream.<T>builder();

		StyleAlias<T>.Builder add(T x)
		{
			builder.accept(x);
			return this;
		}

		java.util.stream.Stream<T> build()
		{
			return builder.<T>build();
		}
	}

	static <A> StyleAlias<A>.Builder builder(A name)
	{
		return new StyleAlias<>(name).new Builder();
	}
}
