class Elevator {
    private final TreeSet<Integer> upRequests   = new TreeSet<>();
    private final TreeSet<Integer> downRequests = new TreeSet<>(Comparator.reverseOrder());
    private final ReentrantLock  lock = new ReentrantLock();
    private       ElevatorState  state = ElevatorState.IDLE;
    private int                   currentFloor = 1;

    // LOOK: service all requests in current direction, then reverse
    public void step() {
        lock.lock();
        try {
            switch (state) {
                case MOVING_UP -> {
                    if (!upRequests.isEmpty()) {
                        currentFloor = upRequests.first();  // next floor up
                        upRequests.remove(currentFloor);
                        state = ElevatorState.STOPPED_OPEN;
                    } else if (!downRequests.isEmpty()) {
                        state = ElevatorState.MOVING_DOWN;  // reverse
                    } else { state = ElevatorState.IDLE; }
                }
                /* ... MOVING_DOWN, STOPPED_OPEN, IDLE cases ... */
            }
        } finally { lock.unlock(); }
    }
}

public boolean borrowBook(String isbn, Member member) {
    Book book = catalog.get(isbn);
    if (book == null) throw new BookNotFoundException(isbn);

    if (book.getAvailable() == 0) {
        reservations.reserve(book, member);  // Join waitlist
        return false;
    }

    // Synchronize on book object — prevents two threads taking last copy
    synchronized (book) {
        if (book.getAvailable() == 0) {  // Double-check after sync
            reservations.reserve(book, member);
            return false;
        }
        book.decrementAvailable();
    }
    activeBorrow.put(member.id+":"+isbn, new Borrowing(book, member));
    return true;
}

public void returnBook(String isbn, Member member) {
    Borrowing b = activeBorrow.remove(member.id+":"+isbn);
    b.markReturned();
    synchronized (b.getBook()) { b.getBook().incrementAvailable(); }
    // Notify next in queue
    reservations.nextInQueue(book).ifPresent(next ->
        observers.forEach(o -> o.onBookAvailable(book, next)));
}

// Chain: Validation → Payment → Delivery → Notification
OrderHandler chain = new ValidationHandler();
chain.setNext(new PaymentHandler(paymentService))
     .setNext(new DeliveryAssignmentHandler(deliveryService))
     .setNext(new NotificationHandler(notifier));

// STRATEGY: surge pricing (pluggable at runtime)
class SurgePricingStrategy implements PricingStrategy {
    public double calculateTotal(Order order) {
        double base  = order.getItems().stream().mapToDouble(Item::getPrice).sum();
        double surge = isPeakHour(order.getTime()) ? 1.3 : 1.0;
        return base * surge + DELIVERY_FEE;
    }
}

// Add new payment method: new class implementing PaymentHandler
// No changes to ValidationHandler, DeliveryHandler, NotificationHandler (OCP)

// PIN retry: 3 attempts then card retained
class CardInsertedState implements ATMState {
    private int attempts = 0;

    public void enterPin(ATM atm, String pin) {
        if (atm.getBank().verifyPin(atm.getCurrentCard(), pin)) {
            atm.setState(new AuthenticatedState());
        } else if (++attempts >= 3) {
            atm.getCardReader().retainCard();  // Swallow card
            atm.setState(new IdleState());
            atm.display("Card retained — 3 failed attempts");
        }
    }
}

// Transaction atomicity: debit then dispense
// If dispense fails → undo() credits account back
class WithdrawalCommand implements Command {
    public void execute() {
        account.debit(amount);   // 1. Debit
        dispenser.dispense(amount); // 2. Dispense (may fail)
    }
    public void undo() {
        account.credit(amount);  // Reversal if dispense failed
        logReversal(transactionId);
    }
}

class Room {
    private final ReentrantLock lock       = new ReentrantLock();
    private final Set<LocalDate> booked    = new HashSet<>();

    public boolean tryBook(LocalDate in, LocalDate out) {
        lock.lock();
        try {
            List<LocalDate> dates = in.datesUntil(out).collect(toList());
            if (dates.stream().anyMatch(booked::contains)) return false;
            booked.addAll(dates);  return true;
        } finally { lock.unlock(); }
    }
}

// Dynamic pricing strategy
class DynamicPricingStrategy implements PricingStrategy {
    public double getPrice(Room room, LocalDate date, int occupancy) {
        double base = room.getBasePrice();
        if (date.getDayOfWeek() == DayOfWeek.FRIDAY
                || date.getDayOfWeek() == DayOfWeek.SATURDAY) base *= 1.2;
        if      (occupancy > 80) base *= 1.5;
        else if (occupancy > 60) base *= 1.2;
        return base;
    }
}