/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * This file is available under and governed by the GNU General Public
 * License version 2 only, as published by the Free Software Foundation.
 * However, the following notice accompanied the original version of this
 * file:
 *
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

package java.util.concurrent;

import android.compat.annotation.UnsupportedAppUsage;

@SuppressWarnings({"unchecked", "deprecation", "all"})
public class ThreadPoolExecutor extends java.util.concurrent.AbstractExecutorService {

    public ThreadPoolExecutor(
            int corePoolSize,
            int maximumPoolSize,
            long keepAliveTime,
            java.util.concurrent.TimeUnit unit,
            java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue) {
        throw new RuntimeException("Stub!");
    }

    public ThreadPoolExecutor(
            int corePoolSize,
            int maximumPoolSize,
            long keepAliveTime,
            java.util.concurrent.TimeUnit unit,
            java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue,
            java.util.concurrent.ThreadFactory threadFactory) {
        throw new RuntimeException("Stub!");
    }

    public ThreadPoolExecutor(
            int corePoolSize,
            int maximumPoolSize,
            long keepAliveTime,
            java.util.concurrent.TimeUnit unit,
            java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue,
            java.util.concurrent.RejectedExecutionHandler handler) {
        throw new RuntimeException("Stub!");
    }

    public ThreadPoolExecutor(
            int corePoolSize,
            int maximumPoolSize,
            long keepAliveTime,
            java.util.concurrent.TimeUnit unit,
            java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue,
            java.util.concurrent.ThreadFactory threadFactory,
            java.util.concurrent.RejectedExecutionHandler handler) {
        throw new RuntimeException("Stub!");
    }

    private static int runStateOf(int c) {
        throw new RuntimeException("Stub!");
    }

    private static int workerCountOf(int c) {
        throw new RuntimeException("Stub!");
    }

    private static int ctlOf(int rs, int wc) {
        throw new RuntimeException("Stub!");
    }

    private static boolean runStateLessThan(int c, int s) {
        throw new RuntimeException("Stub!");
    }

    private static boolean runStateAtLeast(int c, int s) {
        throw new RuntimeException("Stub!");
    }

    private static boolean isRunning(int c) {
        throw new RuntimeException("Stub!");
    }

    private boolean compareAndIncrementWorkerCount(int expect) {
        throw new RuntimeException("Stub!");
    }

    private boolean compareAndDecrementWorkerCount(int expect) {
        throw new RuntimeException("Stub!");
    }

    private void decrementWorkerCount() {
        throw new RuntimeException("Stub!");
    }

    private void advanceRunState(int targetState) {
        throw new RuntimeException("Stub!");
    }

    final void tryTerminate() {
        throw new RuntimeException("Stub!");
    }

    private void checkShutdownAccess() {
        throw new RuntimeException("Stub!");
    }

    private void interruptWorkers() {
        throw new RuntimeException("Stub!");
    }

    private void interruptIdleWorkers(boolean onlyOne) {
        throw new RuntimeException("Stub!");
    }

    private void interruptIdleWorkers() {
        throw new RuntimeException("Stub!");
    }

    final void reject(java.lang.Runnable command) {
        throw new RuntimeException("Stub!");
    }

    void onShutdown() {
        throw new RuntimeException("Stub!");
    }

    final boolean isRunningOrShutdown(boolean shutdownOK) {
        throw new RuntimeException("Stub!");
    }

    private java.util.List<java.lang.Runnable> drainQueue() {
        throw new RuntimeException("Stub!");
    }

    private boolean addWorker(java.lang.Runnable firstTask, boolean core) {
        throw new RuntimeException("Stub!");
    }

    private void addWorkerFailed(java.util.concurrent.ThreadPoolExecutor.Worker w) {
        throw new RuntimeException("Stub!");
    }

    private void processWorkerExit(
            java.util.concurrent.ThreadPoolExecutor.Worker w, boolean completedAbruptly) {
        throw new RuntimeException("Stub!");
    }

    private java.lang.Runnable getTask() {
        throw new RuntimeException("Stub!");
    }

    final void runWorker(java.util.concurrent.ThreadPoolExecutor.Worker w) {
        throw new RuntimeException("Stub!");
    }

    public void execute(java.lang.Runnable command) {
        throw new RuntimeException("Stub!");
    }

    public void shutdown() {
        throw new RuntimeException("Stub!");
    }

    public java.util.List<java.lang.Runnable> shutdownNow() {
        throw new RuntimeException("Stub!");
    }

    public boolean isShutdown() {
        throw new RuntimeException("Stub!");
    }

    public boolean isTerminating() {
        throw new RuntimeException("Stub!");
    }

    public boolean isTerminated() {
        throw new RuntimeException("Stub!");
    }

    public boolean awaitTermination(long timeout, java.util.concurrent.TimeUnit unit)
            throws java.lang.InterruptedException {
        throw new RuntimeException("Stub!");
    }

    protected void finalize() {
        throw new RuntimeException("Stub!");
    }

    public void setThreadFactory(java.util.concurrent.ThreadFactory threadFactory) {
        throw new RuntimeException("Stub!");
    }

    public java.util.concurrent.ThreadFactory getThreadFactory() {
        throw new RuntimeException("Stub!");
    }

    public void setRejectedExecutionHandler(java.util.concurrent.RejectedExecutionHandler handler) {
        throw new RuntimeException("Stub!");
    }

    public java.util.concurrent.RejectedExecutionHandler getRejectedExecutionHandler() {
        throw new RuntimeException("Stub!");
    }

    public void setCorePoolSize(int corePoolSize) {
        throw new RuntimeException("Stub!");
    }

    public int getCorePoolSize() {
        throw new RuntimeException("Stub!");
    }

    public boolean prestartCoreThread() {
        throw new RuntimeException("Stub!");
    }

    void ensurePrestart() {
        throw new RuntimeException("Stub!");
    }

    public int prestartAllCoreThreads() {
        throw new RuntimeException("Stub!");
    }

    public boolean allowsCoreThreadTimeOut() {
        throw new RuntimeException("Stub!");
    }

    public void allowCoreThreadTimeOut(boolean value) {
        throw new RuntimeException("Stub!");
    }

    public void setMaximumPoolSize(int maximumPoolSize) {
        throw new RuntimeException("Stub!");
    }

    public int getMaximumPoolSize() {
        throw new RuntimeException("Stub!");
    }

    public void setKeepAliveTime(long time, java.util.concurrent.TimeUnit unit) {
        throw new RuntimeException("Stub!");
    }

    public long getKeepAliveTime(java.util.concurrent.TimeUnit unit) {
        throw new RuntimeException("Stub!");
    }

    public java.util.concurrent.BlockingQueue<java.lang.Runnable> getQueue() {
        throw new RuntimeException("Stub!");
    }

    public boolean remove(java.lang.Runnable task) {
        throw new RuntimeException("Stub!");
    }

    public void purge() {
        throw new RuntimeException("Stub!");
    }

    public int getPoolSize() {
        throw new RuntimeException("Stub!");
    }

    public int getActiveCount() {
        throw new RuntimeException("Stub!");
    }

    public int getLargestPoolSize() {
        throw new RuntimeException("Stub!");
    }

    public long getTaskCount() {
        throw new RuntimeException("Stub!");
    }

    public long getCompletedTaskCount() {
        throw new RuntimeException("Stub!");
    }

    public java.lang.String toString() {
        throw new RuntimeException("Stub!");
    }

    protected void beforeExecute(java.lang.Thread t, java.lang.Runnable r) {
        throw new RuntimeException("Stub!");
    }

    protected void afterExecute(java.lang.Runnable r, java.lang.Throwable t) {
        throw new RuntimeException("Stub!");
    }

    protected void terminated() {
        throw new RuntimeException("Stub!");
    }

    private static final int CAPACITY = 536870911; // 0x1fffffff

    private static final int COUNT_BITS = 29; // 0x1d

    private static final boolean ONLY_ONE = true;

    private static final int RUNNING = -536870912; // 0xe0000000

    private static final int SHUTDOWN = 0; // 0x0

    private static final int STOP = 536870912; // 0x20000000

    private static final int TERMINATED = 1610612736; // 0x60000000

    private static final int TIDYING = 1073741824; // 0x40000000

    @UnsupportedAppUsage(maxTargetSdk = 30, trackingBug = 170729553)
    private volatile boolean allowCoreThreadTimeOut;

    private long completedTaskCount;

    private volatile int corePoolSize;

    @UnsupportedAppUsage
    private final java.util.concurrent.atomic.AtomicInteger ctl;

    {
        ctl = null;
    }

    @UnsupportedAppUsage(maxTargetSdk = 30, trackingBug = 170729553)
    private static final java.util.concurrent.RejectedExecutionHandler defaultHandler;

    static {
        defaultHandler = null;
    }

    private volatile java.util.concurrent.RejectedExecutionHandler handler;

    private volatile long keepAliveTime;

    private int largestPoolSize;

    @UnsupportedAppUsage(maxTargetSdk = 30, trackingBug = 170729553)
    private final java.util.concurrent.locks.ReentrantLock mainLock;

    {
        mainLock = null;
    }

    private volatile int maximumPoolSize;

    private static final java.lang.RuntimePermission shutdownPerm;

    static {
        shutdownPerm = null;
    }

    private final java.util.concurrent.locks.Condition termination;

    {
        termination = null;
    }

    private volatile java.util.concurrent.ThreadFactory threadFactory;

    private final java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue;

    {
        workQueue = null;
    }

    private final java.util.HashSet<java.util.concurrent.ThreadPoolExecutor.Worker> workers;

    {
        workers = null;
    }

    @SuppressWarnings({"unchecked", "deprecation", "all"})
    public static class AbortPolicy implements java.util.concurrent.RejectedExecutionHandler {

        public AbortPolicy() {
            throw new RuntimeException("Stub!");
        }

        public void rejectedExecution(
                java.lang.Runnable r, java.util.concurrent.ThreadPoolExecutor e) {
            throw new RuntimeException("Stub!");
        }
    }

    @SuppressWarnings({"unchecked", "deprecation", "all"})
    public static class CallerRunsPolicy implements java.util.concurrent.RejectedExecutionHandler {

        public CallerRunsPolicy() {
            throw new RuntimeException("Stub!");
        }

        public void rejectedExecution(
                java.lang.Runnable r, java.util.concurrent.ThreadPoolExecutor e) {
            throw new RuntimeException("Stub!");
        }
    }

    @SuppressWarnings({"unchecked", "deprecation", "all"})
    public static class DiscardOldestPolicy
            implements java.util.concurrent.RejectedExecutionHandler {

        public DiscardOldestPolicy() {
            throw new RuntimeException("Stub!");
        }

        public void rejectedExecution(
                java.lang.Runnable r, java.util.concurrent.ThreadPoolExecutor e) {
            throw new RuntimeException("Stub!");
        }
    }

    @SuppressWarnings({"unchecked", "deprecation", "all"})
    public static class DiscardPolicy implements java.util.concurrent.RejectedExecutionHandler {

        public DiscardPolicy() {
            throw new RuntimeException("Stub!");
        }

        public void rejectedExecution(
                java.lang.Runnable r, java.util.concurrent.ThreadPoolExecutor e) {
            throw new RuntimeException("Stub!");
        }
    }

    @SuppressWarnings({"unchecked", "deprecation", "all"})
    private final class Worker extends java.util.concurrent.locks.AbstractQueuedSynchronizer
            implements java.lang.Runnable {

        Worker(java.lang.Runnable firstTask) {
            throw new RuntimeException("Stub!");
        }

        public void run() {
            throw new RuntimeException("Stub!");
        }

        protected boolean isHeldExclusively() {
            throw new RuntimeException("Stub!");
        }

        protected boolean tryAcquire(int unused) {
            throw new RuntimeException("Stub!");
        }

        protected boolean tryRelease(int unused) {
            throw new RuntimeException("Stub!");
        }

        public void lock() {
            throw new RuntimeException("Stub!");
        }

        public boolean tryLock() {
            throw new RuntimeException("Stub!");
        }

        public void unlock() {
            throw new RuntimeException("Stub!");
        }

        public boolean isLocked() {
            throw new RuntimeException("Stub!");
        }

        void interruptIfStarted() {
            throw new RuntimeException("Stub!");
        }

        volatile long completedTasks;

        java.lang.Runnable firstTask;

        private static final long serialVersionUID = 6138294804551838833L; // 0x552f9a9a47f02c71L

        final java.lang.Thread thread;

        {
            thread = null;
        }
    }
}