static  void add(Runnable hook) 
{
        synchronized (lock) {
            if (state  > RUNNING)
                throw new IllegalStateException("Shutdown in progress");
            hooks.add(hook);
        }
}

 static  void exit(int status) 
{
        boolean runMoreFinalizers = false;
        synchronized (lock) {
            if (status != 0) runFinalizersOnExit = false;
            switch (state) {
            case RUNNING:       /* Initiate shutdown */
                state = HOOKS;
                break;
            case HOOKS:         /* Stall and halt */
                break;
            case FINALIZERS:
                if (status != 0) {
                    /* Halt immediately on nonzero status */
                    halt(status);
                } else {
                    /* Compatibility with old behavior:
                     * Run more finalizers and then halt
                     */
                    runMoreFinalizers = runFinalizersOnExit;
                }
                break;
            }
        }
        if (runMoreFinalizers) {
            runAllFinalizers();
            halt(status);
        }
        synchronized (Shutdown.class) {
            /* Synchronize on the class object, causing any other thread
             * that attempts to initiate shutdown to stall indefinitely
             */
            sequence();
            halt(status);
        }
}

 static  void halt(int status) 
{
        synchronized (haltLock) {
            halt0(status);
        }
}

 static native  void halt0(int status)

 static boolean remove(Runnable hook) 
{
        synchronized (lock) {
            if (state  > RUNNING)
                throw new IllegalStateException("Shutdown in progress");
            if (hook == null) throw new NullPointerException();
            if (hooks == null) {
                return false;
            } else {
                return hooks.remove(hook);
            }
        }
}

 static  void setRunFinalizersOnExit(boolean run) 
{
    /* Invoked by Runtime.runFinalizersOnExit */
        synchronized (lock) {
            runFinalizersOnExit = run;
        }
}

 static  void shutdown() 
{
        synchronized (lock) {
            switch (state) {
            case RUNNING:       /* Initiate shutdown */
                state = HOOKS;
                break;
            case HOOKS:         /* Stall and then return */
            case FINALIZERS:
                break;
            }
        }
        synchronized (Shutdown.class) {
            sequence();
        }
}