1. Flip‑flops JK en modo toggle (J = K = 1):
   Se usan 7 flip‑flops (FF0 a FF6) para representar el contador de 7 bits (0 a 127 en forma normal, pero se limitará a 0–85).
2. Control de Modo Up/Down:
   Se utiliza una señal de control (UP) que, mediante multiplexores, determina la forma de encadenar los flip‑flops:
   • Para conteo ascendente (UP = 1):
     Cada flip‑flop (desde FF1 en adelante) recibe como “reloj” la señal Q del flip‑flop anterior.
   • Para conteo descendente (UP = 0):
     Cada flip‑flop recibe, en lugar de Q, la señal complementada (Q′) del flip‑flop anterior.
   Esto se implementa añadiendo un pequeño multiplexor “virtual” en la entrada de reloj de cada FF (excepto FF0, que siempre se rige por el reloj externo).
3. Lógica de Detección de Rebose/Pérdida para Modulo 86:
   Se agrega un bloque combinacional que:
   • En modo ascendente:
     Detecta cuando el contador llega a 86 (valor binario 1010110) y activa una señal asíncrona de reinicio (clear) para volver a 0.
   • En modo descendente:
     Detecta cuando el contador “decrementa” por debajo de 0 y, en ese instante, activa la carga asíncrona de 85 (preestablece el valor 85 en los flip‑flops).
4. Señales de Control Asíncronas:
   Los flip‑flops deben disponer de entradas asíncronas (clear y/o preload) para forzar el valor en los extremos del conteo (0 o 85) inmediatamente cuando se detecte el rebose.

                   +-----------+
                   |  Reloj    |
                   +-----+-----+
                         |
                        (FF0)
                  +------+------+
                  | JK FF0      |   J=K=1
                  | Q₀ --------+------> [MUX for FF1]
                  +-------------+
                                   UP? --> [MUX 1] --→ Reloj de FF1 (FF1)
                                         |
                  [Para FF1]         /    \  
                                  Q₀   Q₀′   <---- Selección según UP
                                         |
                           +-------------+
                           |    FF1     |   J=K=1
                           | Q₁ -------> [MUX for FF2]  (selección UP)
                           +-------------+
                                         .
                                         .  (se repite para FF2 a FF6)
                                         .
                           +-------------+
                           |    FF6     |   J=K=1
                           | Q₆       (Valor final, bit más significativo)
                           +-------------+

          ┌────────────────────────────────────────────┐
          │ Bloque de Detección de Rebose/Preajuste:   │
          │   - Si UP = 1 y contador = 86 (1010110)      │
          │       -> Clear asíncrono (reset a 0)         │
          │   - Si UP = 0 y contador < 0                  │
          │       -> Carga asíncrona de 85 (1010101)       │
          └────────────────────────────────────────────┘

• Multiplexores para Clock:
  Cada etapa (excepto FF0) debe tener un pequeño circuito (puede ser implementado con compuertas lógicas o un multiplexer dedicado) que seleccione entre la señal directa (para conteo ascendente) o la señal invertida (para conteo descendente) según la señal UP.
• Lógica de Detección:
  La detección del valor límite se hace mediante comparadores lógicos que “leen” el estado de todos los flip‑flops. Cuando se alcanza el valor límite (86 en modo ascendente o 0 en modo descendente, dependiendo de cómo se implemente el preajuste), se activa un clear o carga preestablecida asíncrona en todos los flip‑flops para reiniciar el contador al valor deseado.
• Flip-Flops JK:
  Para la implementación real se puede utilizar un circuito integrado que contenga varios flip‑flops JK (por ejemplo, un 74LS76) u otro similar, siempre asegurándose de disponer de entradas asíncronas para la función de reset o preload.