/**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return {@code true} (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        synchronized (lock) {
            Object[] es = getArray();
            int len = es.length;
            es = Arrays.copyOf(es, len + 1);
            es[len] = e;
            setArray(es);
            return true;
        }
    }

/**
     * Removes the element at the specified position in this list.
     * Shifts any subsequent elements to the left (subtracts one from their
     * indices).  Returns the element that was removed from the list.
     *
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public E remove(int index) {
        synchronized (lock) {
            Object[] es = getArray();
            int len = es.length;
            E oldValue = elementAt(es, index);
            int numMoved = len - index - 1;
            Object[] newElements;
            if (numMoved == 0)
                newElements = Arrays.copyOf(es, len - 1);
            else {
                newElements = new Object[len - 1];
                System.arraycopy(es, 0, newElements, 0, index);
                System.arraycopy(es, index + 1, newElements, index,
                                 numMoved);
            }
            setArray(newElements);
            return oldValue;
        }
    }

_    /**
     * {@inheritDoc}
     *
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public E get(int index) {
        return elementAt(getArray(), index);
__    }_
    
    @SuppressWarnings("unchecked")
    static <E> E elementAt(Object[] a, int index) {
        return (E) a[index];
    }

public class ThreadLocalExample {
    // 创建一个 ThreadLocal 变量
    private static final ThreadLocal<Integer> threadLocalValue = ThreadLocal.withInitial(() -> 0);

    public static void main(String[] args) {
        // 启动两个线程来演示 ThreadLocal 的作用
        Thread thread1 = new Thread(new Task(), "Thread-1");
        Thread thread2 = new Thread(new Task(), "Thread-2");

        thread1.start();
        thread2.start();
    }

    static class Task implements Runnable {
        @Override
        public void run() {
            // 获取当前线程的 ThreadLocal 变量副本的值
            Integer value = threadLocalValue.get();
            System.out.println(Thread.currentThread().getName() + " 初始值: " + value);

            // 修改 ThreadLocal 变量的值
            threadLocalValue.set(value + 1);
            System.out.println(Thread.currentThread().getName() + " 修改后的值: " + threadLocalValue.get());
        }
    }
}

/**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Most subclasses will have no need to
     * override this method, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current thread's copy of
     *        this thread-local.
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            map.set(this, value);
        } else {
            createMap(t, value);
        }
    }

public int[] nextGreaterElements(int[] nums) {
        int n = nums.length;

        int[] res = new int[n];
        Arrays.fill(res, -1);

        Deque<Integer> stack = new LinkedList<>();
        for(int i = 0; i < 2 * n - 1; i++){
            while(!stack.isEmpty() && nums[stack.peek()] < nums[i % n]){
                res[stack.pop()] = nums[i % n];
            }
            stack.push(i % n);
        }
        return res;
    }

public int[] nextGreaterElements(int[] nums) {
        int n = nums.length;
        int[] ans = new int[n];
        
        Arrays.fill(ans, -1);
        Deque<Integer> stack = new LinkedList<>();
        for (int i = 2 * n - 1; i >= 0; i--) {
            int x = nums[i % n];
            while (!stack.isEmpty() && x >= stack.peek()) {
                // 由于 x 的出现，栈顶元素永远不会是左边元素的「下一个更大元素」
                stack.pop();
            }
            if (i < n && !stack.isEmpty()) {
                ans[i] = stack.peek();
            }
            stack.push(x);
        }
        return ans;
    }

/** CLH Nodes */
    abstract static class Node {
        volatile Node prev;       // initially attached via casTail
        volatile Node next;       // visibly nonnull when signallable
        Thread waiter;            // visibly nonnull when enqueued
        volatile int status;      // written by owner, atomic bit ops by others

        // methods for atomic operations
        final boolean casPrev(Node c, Node v) {  // for cleanQueue
            return U.weakCompareAndSetReference(this, PREV, c, v);
        }
        final boolean casNext(Node c, Node v) {  // for cleanQueue
            return U.weakCompareAndSetReference(this, NEXT, c, v);
        }
        final int getAndUnsetStatus(int v) {     // for signalling
            return U.getAndBitwiseAndInt(this, STATUS, ~v);
        }
        final void setPrevRelaxed(Node p) {      // for off-queue assignment
            U.putReference(this, PREV, p);
        }
        final void setStatusRelaxed(int s) {     // for off-queue assignment
            U.putInt(this, STATUS, s);
        }
        final void clearStatus() {               // for reducing unneeded signals
            U.putIntOpaque(this, STATUS, 0);
        }

        private static final long STATUS
            = U.objectFieldOffset(Node.class, "status");
        private static final long NEXT
            = U.objectFieldOffset(Node.class, "next");
        private static final long PREV
            = U.objectFieldOffset(Node.class, "prev");
    }

/**
     * The synchronization state.
     */
    private volatile int state;

    /**
     * Returns the current value of synchronization state.
     * This operation has memory semantics of a {@code volatile} read.
     * @return current state value
     */
    protected final int getState() {
        return state;
    }

    /**
     * Sets the value of synchronization state.
     * This operation has memory semantics of a {@code volatile} write.
     * @param newState the new state value
     */
    protected final void setState(int newState) {
        state = newState;
    }

/**
     * Acquires in exclusive mode, ignoring interrupts.  Implemented
     * by invoking at least once {@link #tryAcquire},
     * returning on success.  Otherwise the thread is queued, possibly
     * repeatedly blocking and unblocking, invoking {@link
     * #tryAcquire} until success.  This method can be used
     * to implement method {@link Lock#lock}.
     *
     * @param arg the acquire argument.  This value is conveyed to
     *        {@link #tryAcquire} but is otherwise uninterpreted and
     *        can represent anything you like.
     */
    public final void acquire(int arg) {
        if (!tryAcquire(arg))
            acquire(null, arg, false, false, false, 0L);
    }

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

private void unparkSuccessor(Node node) {
    // 如果状态是负数，尝试把它设置为0
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    // 得到头结点的后继结点head.next
    Node s = node.next;
    // 如果这个后继结点为空或者状态大于0
    // 通过前面的定义我们知道，大于0只有一种可能，就是这个结点已被取消
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 等待队列中所有还有用的结点，都向前移动
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    // 如果后继结点不为空，
    if (s != null)
        LockSupport.unpark(s.thread);
}

/**
 * Atomically updates Java variable to {@code x} if it is currently
 * holding {@code expected}.
 *
 * <p>This operation has memory semantics of a {@code volatile} read
 * and write.  Corresponds to C11 atomic_compare_exchange_strong.
 *
 * @return {@code true} if successful
 */
@ForceInline
public final boolean compareAndSwapObject(Object o, long offset,
                                          Object expected,
                                          Object x) {
    return theInternalUnsafe.compareAndSetReference(o, offset, expected, x);
}

/**
 * Atomically updates Java variable to {@code x} if it is currently
 * holding {@code expected}.
 *
 * <p>This operation has memory semantics of a {@code volatile} read
 * and write.  Corresponds to C11 atomic_compare_exchange_strong.
 *
 * @return {@code true} if successful
 */
@ForceInline
public final boolean compareAndSwapInt(Object o, long offset,
                                       int expected,
                                       int x) {
    return theInternalUnsafe.compareAndSetInt(o, offset, expected, x);
}

/**
 * Atomically updates Java variable to {@code x} if it is currently
 * holding {@code expected}.
 *
 * <p>This operation has memory semantics of a {@code volatile} read
 * and write.  Corresponds to C11 atomic_compare_exchange_strong.
 *
 * @return {@code true} if successful
 */
@ForceInline
public final boolean compareAndSwapLong(Object o, long offset,
                                        long expected,
                                        long x) {
    return theInternalUnsafe.compareAndSetLong(o, offset, expected, x);
}

_/**_
_ * Basic hash bin node, used for most entries.  (See below for_
_ * TreeNode subclass, and in LinkedHashMap for its Entry subclass.)_
_ */_
static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;

    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

    public final K getKey()        { return key; }
    public final V getValue()      { return value; }
    public final String toString() { return key + "=" + value; }

    public final int hashCode() {
        return Objects._hashCode_(key) ^ Objects._hashCode_(value);
    }

    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {
        if (o == this)
            return true;

        return o instanceof Map.Entry<?, ?> e
                && Objects._equals_(key, e.getKey())
                && Objects._equals_(value, e.getValue());
    }
}

_/**_
_ * Computes key.hashCode() and spreads (XORs) higher bits of hash_
_ * to lower.  Because the table uses power-of-two masking, sets of_
_ * hashes that vary only in bits above the current mask will_
_ * always collide. (Among known examples are sets of Float keys_
_ * holding consecutive whole numbers in small tables.)  So we_
_ * apply a transform that spreads the impact of higher bits_
_ * downward. There is a tradeoff between speed, utility, and_
_ * quality of bit-spreading. Because many common sets of hashes_
_ * are already reasonably distributed (so don't benefit from_
_ * spreading), and because we use trees to handle large sets of_
_ * collisions in bins, we just XOR some shifted bits in the_
_ * cheapest possible way to reduce systematic lossage, as well as_
_ * to incorporate impact of the highest bits that would otherwise_
_ * never be used in index calculations because of table bounds._
_ */_
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

_/**_
_ * Replaces all linked nodes in bin at index for given hash unless_
_ * table is too small, in which case resizes instead._
_ */_
final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    if (tab == null || (n = tab.length) < _MIN_TREEIFY_CAPACITY_)
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        TreeNode<K,V> hd = null, tl = null;
        do {
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
}

/**
 * Initializes or doubles table size.  If null, allocates in
 * accord with initial capacity target held in field threshold.
 * Otherwise, because we are using power-of-two expansion, the
 * elements from each bin must either stay at same index, or move
 * with a power of two offset in the new table.
 *
 * @return the table
 */
final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

_/**_
_ * Entry for Tree bins. Extends LinkedHashMap.Entry (which in turn_
_ * extends Node) so can be used as extension of either regular or_
_ * linked node._
_ */_
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
    TreeNode<K,V> parent;  // red-black tree links
    TreeNode<K,V> left;
    TreeNode<K,V> right;
    TreeNode<K,V> prev;    // needed to unlink next upon deletion
    boolean red;
    TreeNode(int hash, K key, V val, Node<K,V> next) {
        super(hash, key, val, next);
    }

    _/**_
_     * Returns root of tree containing this node._
_     */_
_    _final TreeNode<K,V> root() {
        for (TreeNode<K,V> r = this, p;;) {
            if ((p = r.parent) == null)
                return r;
            r = p;
        }
    }
}

/**
 * Associates the specified value with the specified key in this map.
 * If the map previously contained a mapping for the key, the old
 * value is replaced.
 *
 * @param key key with which the specified value is to be associated
 * @param value value to be associated with the specified key
 * @return the previous value associated with {@code key}, or
 *         {@code null} if there was no mapping for {@code key}.
 *         (A {@code null} return can also indicate that the map
 *         previously associated {@code null} with {@code key}.)
 */
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

/**
 * Implements Map.put and related methods.
 *
 * @param hash hash for key
 * @param key the key
 * @param value the value to put
 * @param onlyIfAbsent if true, don't change existing value
 * @param evict if false, the table is in creation mode.
 * @return previous value, or null if none
 */
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

_/**_
_ * Returns the value to which the specified key is mapped,_
_ * or {_**@code **_null} if this map contains no mapping for the key._
_ *_
_ * <p>More formally, if this map contains a mapping from a key_
_ * {_**@code **_k} to a value {_**@code **_v} such that {_**@code **_(key==null ? k==null :_
_ * key.equals(k))}, then this method returns {_**@code **_v}; otherwise_
_ * it returns {_**@code **_null}.  (There can be at most one such mapping.)_
_ *_
_ * <p>A return value of {_**@code **_null} does not <i>necessarily</i>_
_ * indicate that the map contains no mapping for the key; it's also_
_ * possible that the map explicitly maps the key to {_**@code **_null}._
_ * The {_**@link **_#containsKey containsKey} operation may be used to_
_ * distinguish these two cases._
_ *_
_ * _**@see **_#put(Object, Object)_
_ */_
public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(key)) == null ? null : e.value;
}

_/**_
_ * Implements Map.get and related methods._
_ *_
_ * _**@param **_key the key_
_ * _**@return **_the node, or null if none_
_ */_
final Node<K,V> getNode(Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n, hash; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & (hash = _hash_(key))]) != null) {
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) {
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

_/**_
_ * Constructs a new, empty set; the backing {_**@code **_HashMap} instance has_
_ * default initial capacity (16) and load factor (0.75)._
_ */_
public HashSet() {
    map = new HashMap<>();
}

_/**_
_ * Constructs a new set containing the elements in the specified_
_ * collection.  The {_**@code **_HashMap} is created with default load factor_
_ * (0.75) and an initial capacity sufficient to contain the elements in_
_ * the specified collection._
_ *_
_ * _**@param **_c the collection whose elements are to be placed into this set_
_ * _**@throws **_NullPointerException if the specified collection is null_
_ */_
public HashSet(Collection<? extends E> c) {
    map = new HashMap<>(Math._max_((int) (c.size()/.75f) + 1, 16));
    addAll(c);
}

_/**_
_ * Constructs a new, empty set; the backing {_**@code **_HashMap} instance has_
_ * the specified initial capacity and the specified load factor._
_ *_
_ * _**@param      **_initialCapacity   the initial capacity of the hash map_
_ * _**@param      **_loadFactor        the load factor of the hash map_
_ * _**@throws     **_IllegalArgumentException if the initial capacity is less_
_ *             than zero, or if the load factor is nonpositive_
_ */_
public HashSet(int initialCapacity, float loadFactor) {
    map = new HashMap<>(initialCapacity, loadFactor);
}

_/**_
_ * Constructs a new, empty set; the backing {_**@code **_HashMap} instance has_
_ * the specified initial capacity and default load factor (0.75)._
_ *_
_ * _**@param      **_initialCapacity   the initial capacity of the hash table_
_ * _**@throws     **_IllegalArgumentException if the initial capacity is less_
_ *             than zero_
_ */_
public HashSet(int initialCapacity) {
    map = new HashMap<>(initialCapacity);
}

_/**_
_ * Constructs a new, empty linked hash set.  (This package private_
_ * constructor is only used by LinkedHashSet.) The backing_
_ * HashMap instance is a LinkedHashMap with the specified initial_
_ * capacity and the specified load factor._
_ *_
_ * _**@param      **_initialCapacity   the initial capacity of the hash map_
_ * _**@param      **_loadFactor        the load factor of the hash map_
_ * _**@param      **_dummy             ignored (distinguishes this_
_ *             constructor from other int, float constructor.)_
_ * _**@throws     **_IllegalArgumentException if the initial capacity is less_
_ *             than zero, or if the load factor is nonpositive_
_ */_
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
    map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

// Dummy value to associate with an Object in the backing Map
private static final Object _PRESENT _= new Object();

/**
 * Adds the specified element to this set if it is not already present.
 * More formally, adds the specified element {@code e} to this set if
 * this set contains no element {@code e2} such that
 * {@code Objects.equals(e, e2)}.
 * If this set already contains the element, the call leaves the set
 * unchanged and returns {@code false}.
 *
 * @param e element to be added to this set
 * @return {@code true} if this set did not already contain the specified
 * element
 */
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

/**
 * Initializes table, using the size recorded in sizeCtl.
 */
private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        if ((sc = sizeCtl) < 0)
            Thread.yield(); // lost initialization race; just spin
        else if (U.compareAndSetInt(this, SIZECTL, sc, -1)) {
            try {
                if ((tab = table) == null || tab.length == 0) {
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    @SuppressWarnings("unchecked")
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    table = tab = nt;
                    sc = n - (n >>> 2);
                }
            } finally {
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}

_/**_
_ * Maps the specified key to the specified value in this table._
_ * Neither the key nor the value can be null._
_ *_
_ * <p>The value can be retrieved by calling the {_**@code **_get} method_
_ * with a key that is equal to the original key._
_ *_
_ * _**@param **_key key with which the specified value is to be associated_
_ * _**@param **_value value to be associated with the specified key_
_ * _**@return **_the previous value associated with {_**@code **_key}, or_
_ *         {_**@code **_null} if there was no mapping for {_**@code **_key}_
_ * _**@throws **_NullPointerException if the specified key or value is null_
_ */_
public V put(K key, V value) {
    return putVal(key, value, false);
}

_/** Implementation for put and putIfAbsent */_
final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    int hash = _spread_(key.hashCode());
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh; K fk; V fv;
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        else if ((f = _tabAt_(tab, i = (n - 1) & hash)) == null) {
            if (_casTabAt_(tab, i, null, new Node<K,V>(hash, key, value)))
                break;                   // no lock when adding to empty bin
        }
        else if ((fh = f.hash) == _MOVED_)
            tab = helpTransfer(tab, f);
        else if (onlyIfAbsent // check first node without acquiring lock
                 && fh == hash
                 && ((fk = f.key) == key || (fk != null && key.equals(fk)))
                 && (fv = f.val) != null)
            return fv;
        else {
            V oldVal = null;
            synchronized (f) {
                if (_tabAt_(tab, i) == f) {
                    if (fh >= 0) {
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key, value);
                                break;
                            }
                        }
                    }
                    else if (f instanceof TreeBin) {
                        Node<K,V> p;
                        binCount = 2;
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                       value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                    else if (f instanceof ReservationNode)
                        throw new IllegalStateException("Recursive update");
                }
            }
            if (binCount != 0) {
                if (binCount >= _TREEIFY_THRESHOLD_)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{

    /**
     * Default initial capacity.
     * 默认初始大小为10
     */
    private static final int DEFAULT_CAPACITY = 10;
    
    /**
    * ArrayList底层是Object数组
    */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * The size of the ArrayList (the number of elements it contains).
     * @serial
     */
    private int size;
    
    /**
    * 带初始大小的构造方法
    */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = _EMPTY_ELEMENTDATA_;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

    /**
    * 默认无参构造函数，此时数组大小初始化为10
    */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    
    /**
    * 如有必要，增加此ArrayList实例的容量，以确保它至少能容纳元素的数量
    *
    * @param minCapacity 所需的最小容量
    */
    public void ensureCapacity(int minCapacity) {
        //如果是true，minExpand的值为0，如果是false,minExpand的值为10
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
                // any size if not default element table
                ? 0
                // larger than default for default empty table. It's already
                // supposed to be at default size.
                : DEFAULT_CAPACITY;
        //如果最小容量大于已有的最大容量
        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }

   
    // 根据给定的最小容量和当前数组元素来计算所需容量。
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        // 如果当前数组元素为空数组（初始情况），返回默认容量和最小容量中的较大值作为所需容量
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        // 否则直接返回最小容量
        return minCapacity;
    }

    // 确保内部容量达到指定的最小容量。
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    //判断是否需要扩容
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            //调用grow方法进行扩容，调用此方法代表已经开始扩容了
            grow(minCapacity);
    }


    /**
     * ArrayList扩容的核心方法。
     */
    private void grow(int minCapacity) {
        // oldCapacity为旧容量，newCapacity为新容量
        int oldCapacity = elementData.length;
        
        //将oldCapacity 右移一位，其效果相当于oldCapacity /2，
        //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        
        //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //再检查新容量是否超出了ArrayList所定义的最大容量，
        //若超出了，则调用hugeCapacity()来比较minCapacity和 MAX_ARRAY_SIZE，
        //如果minCapacity大于MAX_ARRAY_SIZE，则新容量则为Integer.MAX_VALUE，否则，新容量大小则为 MAX_ARRAY_SIZE。
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

}

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    transient int size = 0;

    /**
     * Pointer to first node.
     * 头节点
     */
    transient Node<E> first;

    /**
     * Pointer to last node.
     * 尾节点
     */
    transient Node<E> last;

    /**
     * Constructs an empty list.
     * 默认构造函数，构造空链表
     */
    public LinkedList() {
    }


    /**
     * Returns the first element in this list.
     * 返回第一个节点元素
     * @return the first element in this list
     * @throws NoSuchElementException if this list is empty
     */
    public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }

    /**
     * Returns the last element in this list.
     * 返回末尾节点元素
     * @return the last element in this list
     * @throws NoSuchElementException if this list is empty
     */
    public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }

     /**
     * Appends the specified element to the end of this list.
     * 将元素加入链表的末尾
     * <p>This method is equivalent to {@link #addLast}.
     *
     * @param e element to be appended to this list
     * @return {@code true} (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        linkLast(e);
        return true;
    }
    
    
    /**
    * Links e as last element.
    * add函数中调用的方法，将e连接至链表末尾
    */
    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

7
1 2
2 3
5
0
5
-1
-1

2 4 5 6

public class Solution {

    static int n;
    
    static List<Integer>[] adj;
    
    static Set<Integer> set;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        n = in.nextInt();

        adj = new List[n];
        set = new HashSet<>();
        in.nextLine();
        int end = -1;
        
        //邻接矩阵的构造
        for (int i = 0; i < n; i++) {
            String[] temp = in.nextLine().split(" ");
            adj[i] = new ArrayList<>(temp.length);

            for (String s : temp) {
                Integer val = Integer.parseInt(s);
                if (val == -1) {
                    end = val;
                    set.add(i);
                }
                adj[i].add(val);
            }
        }

        boolean p = true;

        while(p) {
            p = false;
            for (int i = 0; i < n; i++) {
                if(set.contains(i)) continue;

                if (check(i)) {
                    set.add(i);
                    p = true;
                }
            }
        }
        
        List<Integer> ans = new ArrayList<>(set);
        ans.sort(null);
        for (Integer a : ans) {
            System.out.print(a + " ");
        }
    }
    
    //检查一个工序指向的是否全是合规工序
    private static boolean check(int i){
        for (Integer j : adj[i]) {
            if(!set.contains(j)) return false;
        }
        return true;
    }
}

class Solution {

    static Map<Long, Long> memo = new HashMap<>();

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Scanner in = new Scanner(System.in);

        long upLimit = in.nextInt();
        long sum = in.nextInt();

        long ans = dfs(sum, 1);
        
        System.out.println(ans > upLimit);
    }

    private static long dfs(long num, long mul){
        //num 为1或为0时直接返回
        if(num == 0 || num == 1) return mul;

        //如果已经计算过，就直接返回
        if(memo.containsKey(num)) return memo.get(num) * mul;

        long max = num * mul;
        for(int i = 1; i < num; i++){
            max = Math.max(max, dfs(num - i, mul * i));
        }
        memo.put(num, max / mul);
        return max;
    }
}

public int majorityElement(int[] nums) {
    int count = 0;
    int candidate = 0;
    
    for(int num : nums){
        if(count == 0) candidate = num;

        count += (num == candidate) ? 1 : -1;
    }
    return candidate;
}

public int majorityElement(int[] nums) {
    Random random = new Random();

    int target = nums.length / 2;

    while (true){
        int candidate = random.nextInt(nums.length);
        int count = 0;
        
        for(int num : nums){
            if(num == candidate) count++;
        }
        if(count >= target) return candidate;
    }
}

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence,
               Constable, ConstantDesc {

    ...
    @Stable
    private final byte[] value;
    
}

public static void main(String[] args) throws Exception {
    String s = "aaa";
    _appendString_(s);
    System._out_.println("String aaa >>> "+s);
}

public static void appendString(String s){
    s += "bbb";
}

//String aaa >>> aaa

public static void main(String[] args) {
    for (int i = 1; i < 1000; i++) {
        int count = 0;
        for(int j = 1; j < i; j++){
            if(i % j == 0) count++;
        }
        if(count == 2) System._out_.println(i);
    }
}

4
9
25
49
121
169
289
361
529
841
961

public int nonSpecialCount(int l, int r) {
        int low = (int) Math.sqrt(l);
        int up = (int) Math.sqrt(r);

        if(low * low < l) low++;//确保在[√l, √r]的区间内

        int count = 0;
        for(int i = Math.max(low, 2); i <= up; i++){
            if(isPrime(i)) count++;
        }
        return r - l + 1 - count ;
    }
    
    private boolean isPrime(int num){
        for(int i = 2; i * i <= num; i++){
            if(num % i == 0) return false;
        }
        return true;
    }