"""
=============================================================================
Sección Declarativa - Programa Principal

Descripción: Multiplica dos números enteros utilizando el algoritmo de la 
campesina rusa (complejidad O(log b)), delegando el manejo de signos y 
la lógica binaria en funciones modulares.

Casos de prueba:
- 13 x 11 -> 143 (Caso normal)
- 3 x 4 -> 12 (Acumula solo cuando b impar)
- 7 x 0 -> 0 (Caso límite)
- -3 x 4 -> -12 (Signo negativo, opera con absolutos)

Recursos del programa principal:
- num1, num2 (int): Factores ingresados por el usuario.
- resultado (int): Producto calculado.
=============================================================================
"""

# ==========================================
# DEFINICIÓN DE FUNCIONES
# ==========================================

def campesina_rusa(a, b):
    """
    Sección Declarativa de Función
    Descripción: Aplica el algoritmo de la campesina rusa para enteros no negativos.
    Precondición: a >= 0, b >= 0.
    Postcondición: Retorna a * b calculado en O(log b) pasos.
    Parámetros:
    - a (int): Multiplicando (se duplica).
    - b (int): Multiplicador (se divide a la mitad).
    Variables locales:
    - resultado (int): Acumulador de las sumas parciales.
    """
    resultado = 0
    print(f"\nTRAZA\n{20*' '}\t{chr(0x2192)}{resultado:10}")
    # El algoritmo finaliza cuando el multiplicador b llega a 0.
    while b > 0:
        # Se verifica si b es impar evaluando su bit menos significativo.
        if b & 1 == 1:
            resultado = resultado + a  # Acumula si es impar
        print(f"{a:10d}{b:10d}\t{chr(0x2192)}{resultado:10d}")
        
        # Corrimiento de bits: << 1 duplica 'a', >> 1 calcula la mitad entera de 'b'.
        a = a << 1
        b = b >> 1
        
    return resultado

def multiplicar(a, b):
    """
    Sección Declarativa de Función
    Descripción: Envoltorio (wrapper) que maneja los signos de los factores, 
    convierte a valores absolutos, invoca a campesina_rusa y restaura el signo.
    Parámetros:
    - a, b (int): Factores con signo.
    Variables locales:
    - signo (int): +1 si el resultado es positivo, -1 si es negativo.
    - abs_a, abs_b (int): Valores absolutos de los factores.
    """
    # Determinación matemática del signo (XOR lógico)
    if (a < 0) != (b < 0):
        signo = -1
    else:
        signo = 1
        
    abs_a = -a if a < 0 else a
    abs_b = -b if b < 0 else b
    
    # Invocación a la función central con los valores absolutos
    producto_absoluto = campesina_rusa(abs_a, abs_b)
    
    return producto_absoluto if signo == 1 else -producto_absoluto

# ==========================================
# SECCIÓN ALGORÍTMICA
# ==========================================

# 1) Prólogo 
print("--- Multiplicación: Algoritmo de la Campesina Rusa ---")
num1 = int(input("Ingrese el primer entero: "))
num2 = int(input("Ingrese el segundo entero: "))

# 2) Desarrollo 
# Se delega toda la responsabilidad del cálculo a la función principal
resultado = multiplicar(num1, num2)

# 3) Epílogo 
print(f"\nResultado de {num1} x {num2} = {resultado}")
input("Pulse Enter para terminar el programa")