import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Supplier;

@SuppressWarnings("unused")
@Marker(name = "Sample", numbers = {1, 2, 3}, nested = @NestedMarker, kind = Marker.Kind.SECOND)
@InvisibleMarker
public class Sample<T extends Comparable<T>> extends SampleBase implements Runnable {
    static final int INT = 42;
    static final long LONG = 0x0102_0304_0506_0708L;
    static final float FLOAT = 3.5f;
    static final double DOUBLE = 1.0e300;
    static final String STRING = "plain";

    static final String NUL = "a\0b";
    static final String ASTRAL = "🦀 crab";
    static final String CYRILLIC = "привет";

    int поле;

    Map<String, List<T>> generic;
    T[] array;

    private volatile transient int mutable;

    public Sample() {
        super(INT);
    }

    public <R> R exchange(
            T key,
            @Marker(name = "value") R value,
            @InvisibleMarker("rest") int... rest)
            throws IOException {
        if (rest.length == 0) {
            throw new IOException(STRING);
        }

        return value;
    }

    int handlers(int input) {
        try {
            return 1 / input;
        } catch (ArithmeticException | NullPointerException error) {
            return -1;
        } finally {
            mutable = input;
        }
    }

    int frames(int input, Object object) {
        int total = 0;

        for (int index = 0; index < input; index++) {
            String local = String.valueOf(index);
            total += local.length();

            if (object instanceof List) {
                List<?> list = (List<?>) object;
                total += list.size();
            }
        }

        switch (input) {
            case 0:
                total = 0;
                break;
            case 7:
                total = 7;
                break;
            default:
                total = -total;
        }

        double wide = total;
        long alsoWide = total;

        return (int) (wide + alsoWide);
    }

    Supplier<String> lambda() {
        return () -> STRING + поле;
    }

    Supplier<List<T>> methodReference() {
        return ArrayList::new;
    }

    Runnable anonymous() {
        class Local implements Runnable {
            @Override
            public void run() {
                mutable++;
            }
        }

        new Local().run();

        return new Runnable() {
            @Override
            public void run() {
                mutable--;
            }
        };
    }

    native void nativeMethod(long handle);

    strictfp double strict(double value) {
        return value * value;
    }

    synchronized void locked() {
        mutable = 0;
    }

    @Deprecated
    void deprecated() {}

    @Override
    public void run() {}

    @Override
    public Sample<T> self() {
        return this;
    }

    public static class Nested {
        public int value;
    }

    public class Inner {
        public int outerField() {
            return поле;
        }
    }

    public interface Callback {
        void accept(String value);
    }
}