// Path: src/main/java/com/lmax/disruptor/EventHandler.java
// public interface EventHandler<T>
// {
//     /**
//      * Called when a publisher has published an event to the {@link RingBuffer}
//      *
//      * @param event published to the {@link RingBuffer}
//      * @param sequence of the event being processed
//      * @param endOfBatch flag to indicate if this is the last event in a batch from the {@link RingBuffer}
//      * @throws Exception if the EventHandler would like the exception handled further up the chain.
//      */
//     void onEvent(T event, long sequence, boolean endOfBatch) throws Exception;
// }
// 
// Path: src/main/java/com/lmax/disruptor/EventProcessor.java
// public interface EventProcessor extends Runnable
// {
//     /**
//      * Get a reference to the {@link Sequence} being used by this {@link EventProcessor}.
//      *
//      * @return reference to the {@link Sequence} for this {@link EventProcessor}
//      */
//     Sequence getSequence();
// 
//     /**
//      * Signal that this EventProcessor should stop when it has finished consuming at the next clean break.
//      * It will call {@link SequenceBarrier#alert()} to notify the thread to check status.
//      */
//     void halt();
// }
// 
// Path: src/main/java/com/lmax/disruptor/SequenceBarrier.java
// public interface SequenceBarrier
// {
//     /**
//      * Wait for the given sequence to be available for consumption.
//      *
//      * @param sequence to wait for
//      * @return the sequence up to which is available
//      * @throws AlertException if a status change has occurred for the Disruptor
//      * @throws InterruptedException if the thread needs awaking on a condition variable.
//      */
//     long waitFor(long sequence) throws AlertException, InterruptedException;
// 
//     /**
//      * Wait for the given sequence to be available for consumption with a time out.
//      *
//      * @param sequence to wait for
//      * @param timeout value
//      * @param units for the timeout value
//      * @return the sequence up to which is available
//      * @throws AlertException if a status change has occurred for the Disruptor
//      * @throws InterruptedException if the thread needs awaking on a condition variable.
//      */
//     long waitFor(long sequence, long timeout, TimeUnit units) throws AlertException, InterruptedException;
// 
//     /**
//      * Delegate a call to the {@link Sequencer#getCursor()}
//      *
//      * @return value of the cursor for entries that have been published.
//      */
//     long getCursor();
// 
//     /**
//      * The current alert status for the barrier.
//      *
//      * @return true if in alert otherwise false.
//      */
//     boolean isAlerted();
// 
//     /**
//      * Alert the {@link EventProcessor}s of a status change and stay in this status until cleared.
//      */
//     void alert();
// 
//     /**
//      * Clear the current alert status.
//      */
//     void clearAlert();
// 
//     /**
//      * Check if an alert has been raised and throw an {@link AlertException} if it has.
//      *
//      * @throws AlertException if alert has been raised.
//      */
//     void checkAlert() throws AlertException;
// }
// 
// Path: src/main/java/com/lmax/disruptor/util/Util.java
// public final class Util
// {
//     /**
//      * Calculate the next power of 2, greater than or equal to x.<p>
//      * From Hacker's Delight, Chapter 3, Harry S. Warren Jr.
//      *
//      * @param x Value to round up
//      * @return The next power of 2 from x inclusive
//      */
//     public static int ceilingNextPowerOfTwo(final int x)
//     {
//         return 1 << (32 - Integer.numberOfLeadingZeros(x - 1));
//     }
// 
//     /**
//      * Get the minimum sequence from an array of {@link com.lmax.disruptor.Sequence}s.
//      *
//      * @param sequences to compare.
//      * @return the minimum sequence found or Long.MAX_VALUE if the array is empty.
//      */
//     public static long getMinimumSequence(final Sequence[] sequences)
//     {
//         long minimum = Long.MAX_VALUE;
// 
//         for (Sequence sequence : sequences)
//         {
//             long value = sequence.get();
//             minimum = minimum < value ? minimum : value;
//         }
// 
//         return minimum;
//     }
// 
//     /**
//      * Get an array of {@link Sequence}s for the passed {@link EventProcessor}s
//      *
//      * @param processors for which to get the sequences
//      * @return the array of {@link Sequence}s
//      */
//     public static Sequence[] getSequencesFor(final EventProcessor... processors)
//     {
//         Sequence[] sequences = new Sequence[processors.length];
//         for (int i = 0; i < sequences.length; i++)
//         {
//             sequences[i] = processors[i].getSequence();
//         }
// 
//         return sequences;
//     }
// }


import com.lmax.disruptor.EventHandler;
import com.lmax.disruptor.EventProcessor;
import com.lmax.disruptor.SequenceBarrier;
import com.lmax.disruptor.util.Util;
     */
    public EventHandlerGroup<T> then(final EventHandler<T>... handlers)
    {
        return handleEventsWith(handlers);
    }

    /**
     * Set up batch handlers to handleEventException events from the ring buffer. These handlers will only process events
     * after every {@link EventProcessor} in this group has processed the event.
     *
     * <p>This method is generally used as part of a chain. For example if the handler <code>A</code> must
     * process events before handler <code>B</code>:</p>
     *
     * <pre><code>dw.after(A).handleEventsWith(B);</code></pre>
     *
     * @param handlers the batch handlers that will process events.
     * @return a {@link EventHandlerGroup} that can be used to set up a event processor barrier over the created event processors.
     */
    public EventHandlerGroup<T> handleEventsWith(final EventHandler<T>... handlers)
    {
        return disruptor.createEventProcessors(eventProcessors, handlers);
    }

    /**
     * Create a dependency barrier for the processors in this group.
     * This allows custom event processors to have dependencies on
     * {@link com.lmax.disruptor.BatchEventProcessor}s created by the disruptor.
     *
     * @return a {@link SequenceBarrier} including all the processors in this group.
     */
// Path: src/main/java/com/lmax/disruptor/EventHandler.java
// public interface EventHandler<T>
// {
//     /**
//      * Called when a publisher has published an event to the {@link RingBuffer}
//      *
//      * @param event published to the {@link RingBuffer}
//      * @param sequence of the event being processed
//      * @param endOfBatch flag to indicate if this is the last event in a batch from the {@link RingBuffer}
//      * @throws Exception if the EventHandler would like the exception handled further up the chain.
//      */
//     void onEvent(T event, long sequence, boolean endOfBatch) throws Exception;
// }
// 
// Path: src/main/java/com/lmax/disruptor/EventProcessor.java
// public interface EventProcessor extends Runnable
// {
//     /**
//      * Get a reference to the {@link Sequence} being used by this {@link EventProcessor}.
//      *
//      * @return reference to the {@link Sequence} for this {@link EventProcessor}
//      */
//     Sequence getSequence();
// 
//     /**
//      * Signal that this EventProcessor should stop when it has finished consuming at the next clean break.
//      * It will call {@link SequenceBarrier#alert()} to notify the thread to check status.
//      */
//     void halt();
// }
// 
// Path: src/main/java/com/lmax/disruptor/SequenceBarrier.java
// public interface SequenceBarrier
// {
//     /**
//      * Wait for the given sequence to be available for consumption.
//      *
//      * @param sequence to wait for
//      * @return the sequence up to which is available
//      * @throws AlertException if a status change has occurred for the Disruptor
//      * @throws InterruptedException if the thread needs awaking on a condition variable.
//      */
//     long waitFor(long sequence) throws AlertException, InterruptedException;
// 
//     /**
//      * Wait for the given sequence to be available for consumption with a time out.
//      *
//      * @param sequence to wait for
//      * @param timeout value
//      * @param units for the timeout value
//      * @return the sequence up to which is available
//      * @throws AlertException if a status change has occurred for the Disruptor
//      * @throws InterruptedException if the thread needs awaking on a condition variable.
//      */
//     long waitFor(long sequence, long timeout, TimeUnit units) throws AlertException, InterruptedException;
// 
//     /**
//      * Delegate a call to the {@link Sequencer#getCursor()}
//      *
//      * @return value of the cursor for entries that have been published.
//      */
//     long getCursor();
// 
//     /**
//      * The current alert status for the barrier.
//      *
//      * @return true if in alert otherwise false.
//      */
//     boolean isAlerted();
// 
//     /**
//      * Alert the {@link EventProcessor}s of a status change and stay in this status until cleared.
//      */
//     void alert();
// 
//     /**
//      * Clear the current alert status.
//      */
//     void clearAlert();
// 
//     /**
//      * Check if an alert has been raised and throw an {@link AlertException} if it has.
//      *
//      * @throws AlertException if alert has been raised.
//      */
//     void checkAlert() throws AlertException;
// }
// 
// Path: src/main/java/com/lmax/disruptor/util/Util.java
// public final class Util
// {
//     /**
//      * Calculate the next power of 2, greater than or equal to x.<p>
//      * From Hacker's Delight, Chapter 3, Harry S. Warren Jr.
//      *
//      * @param x Value to round up
//      * @return The next power of 2 from x inclusive
//      */
//     public static int ceilingNextPowerOfTwo(final int x)
//     {
//         return 1 << (32 - Integer.numberOfLeadingZeros(x - 1));
//     }
// 
//     /**
//      * Get the minimum sequence from an array of {@link com.lmax.disruptor.Sequence}s.
//      *
//      * @param sequences to compare.
//      * @return the minimum sequence found or Long.MAX_VALUE if the array is empty.
//      */
//     public static long getMinimumSequence(final Sequence[] sequences)
//     {
//         long minimum = Long.MAX_VALUE;
// 
//         for (Sequence sequence : sequences)
//         {
//             long value = sequence.get();
//             minimum = minimum < value ? minimum : value;
//         }
// 
//         return minimum;
//     }
// 
//     /**
//      * Get an array of {@link Sequence}s for the passed {@link EventProcessor}s
//      *
//      * @param processors for which to get the sequences
//      * @return the array of {@link Sequence}s
//      */
//     public static Sequence[] getSequencesFor(final EventProcessor... processors)
//     {
//         Sequence[] sequences = new Sequence[processors.length];
//         for (int i = 0; i < sequences.length; i++)
//         {
//             sequences[i] = processors[i].getSequence();
//         }
// 
//         return sequences;
//     }
// }


// Path: src/main/java/com/lmax/disruptor/dsl/EventHandlerGroup.java
import com.lmax.disruptor.EventHandler;
import com.lmax.disruptor.EventProcessor;
import com.lmax.disruptor.SequenceBarrier;
import com.lmax.disruptor.util.Util;

     */
    public EventHandlerGroup<T> then(final EventHandler<T>... handlers)
    {
        return handleEventsWith(handlers);
    }

    /**
     * Set up batch handlers to handleEventException events from the ring buffer. These handlers will only process events
     * after every {@link EventProcessor} in this group has processed the event.
     *
     * <p>This method is generally used as part of a chain. For example if the handler <code>A</code> must
     * process events before handler <code>B</code>:</p>
     *
     * <pre><code>dw.after(A).handleEventsWith(B);</code></pre>
     *
     * @param handlers the batch handlers that will process events.
     * @return a {@link EventHandlerGroup} that can be used to set up a event processor barrier over the created event processors.
     */
    public EventHandlerGroup<T> handleEventsWith(final EventHandler<T>... handlers)
    {
        return disruptor.createEventProcessors(eventProcessors, handlers);
    }

    /**
     * Create a dependency barrier for the processors in this group.
     * This allows custom event processors to have dependencies on
     * {@link com.lmax.disruptor.BatchEventProcessor}s created by the disruptor.
     *
     * @return a {@link SequenceBarrier} including all the processors in this group.
     */
    public SequenceBarrier asSequenceBarrier()