def hash_element(element):
    """Transform element to hash value"""
    import hashlib
    hash_value = hashlib.md5(str(element).encode()).hexdigest()
    return int(hash_value, 16)

def count_leading_zeros(hash_value):
    """Count leading zeros in hash value"""
    binary = bin(hash_value)[2:]  # Remove '0b'
    leading_zeros = 0
    for bit in binary:
        if bit == '0':
            leading_zeros += 1
        else:
            break
    return leading_zeros

def estimate_cardinality(leading_zero_counts, m):
    """Estimate cardinality"""
    import math
    
    # Calculate harmonic mean
    harmonic_mean = m / sum(2**(-count) for count in leading_zero_counts)
    
    # Apply correction factor
    alpha_m = {
        16: 0.673, 32: 0.697, 64: 0.709, 128: 0.715, 256: 0.718,
        512: 0.720, 1024: 0.722, 2048: 0.723, 4096: 0.724
    }
    
    raw_estimate = alpha_m.get(m, 0.7213 / (1 + 1.079 / m)) * m * harmonic_mean
    
    # Small cardinality correction
    if raw_estimate <= 2.5 * m:
        zeros = leading_zero_counts.count(0)
        if zeros > 0:
            return m * math.log(m / zeros)
    
    # Large cardinality correction
    if raw_estimate > (2**32) / 30:
        return -(2**32) * math.log(1 - raw_estimate / (2**32))
    
    return raw_estimate

class RealTimeWebAnalytics:
    def __init__(self):
        self.daily_users = HyperLogLog(precision=14)  # 99.9% accuracy
        self.hourly_users = HyperLogLog(precision=12)  # 99% accuracy
        self.realtime_users = HyperLogLog(precision=10)  # 95% accuracy
    
    def process_event(self, user_id, timestamp):
        """Process real-time events"""
        # Estimate daily active users
        self.daily_users.add(user_id)
        
        # Estimate hourly active users
        if self.is_current_hour(timestamp):
            self.hourly_users.add(user_id)
        
        # Estimate real-time active users (last 5 minutes)
        if self.is_recent_5min(timestamp):
            self.realtime_users.add(user_id)
    
    def get_metrics(self):
        """Return real-time metrics"""
        return {
            "daily_active_users": self.daily_users.estimate(),
            "hourly_active_users": self.hourly_users.estimate(),
            "realtime_active_users": self.realtime_users.estimate()
        }

class MarketingAnalytics:
    def __init__(self):
        self.campaign_clicks = {}
        self.campaign_purchases = {}
        self.ab_test_groups = {}
    
    def track_campaign_click(self, user_id, campaign_id, ab_test_group=None):
        """Track campaign clicks"""
        if campaign_id not in self.campaign_clicks:
            self.campaign_clicks[campaign_id] = HyperLogLog(precision=12)
        
        self.campaign_clicks[campaign_id].add(user_id)
        
        # Track by A/B test group
        if ab_test_group:
            key = f"{campaign_id}_{ab_test_group}"
            if key not in self.ab_test_groups:
                self.ab_test_groups[key] = HyperLogLog(precision=12)
            self.ab_test_groups[key].add(user_id)
    
    def track_purchase(self, user_id, campaign_id):
        """Track purchases"""
        if campaign_id not in self.campaign_purchases:
            self.campaign_purchases[campaign_id] = HyperLogLog(precision=12)
        
        self.campaign_purchases[campaign_id].add(user_id)
    
    def get_campaign_metrics(self, campaign_id):
        """Calculate campaign metrics"""
        clicks = self.campaign_clicks.get(campaign_id, HyperLogLog()).estimate()
        purchases = self.campaign_purchases.get(campaign_id, HyperLogLog()).estimate()
        
        return {
            "unique_clicks": clicks,
            "unique_purchases": purchases,
            "conversion_rate": purchases / clicks if clicks > 0 else 0
        }
    
    def get_ab_test_results(self, campaign_id):
        """Compare A/B test results"""
        results = {}
        for group in ["A", "B"]:
            key = f"{campaign_id}_{group}"
            if key in self.ab_test_groups:
                results[group] = {
                    "unique_clicks": self.ab_test_groups[key].estimate(),
                    "conversion_rate": self.get_campaign_metrics(campaign_id)["conversion_rate"]
                }
        return results

class NetworkSecurityMonitor:
    def __init__(self):
        self.ip_tracker = HyperLogLog(precision=14)
        self.port_tracker = HyperLogLog(precision=10)
        self.attack_threshold = 100000  # IP count threshold
    
    def monitor_traffic(self, ip_address, port, timestamp):
        """Monitor network traffic"""
        # Track unique IP addresses
        self.ip_tracker.add(ip_address)
        
        # Track unique ports
        self.port_tracker.add(port)
        
        # Detect DDoS attacks
        unique_ips = self.ip_tracker.estimate()
        if unique_ips > self.attack_threshold:
            self.trigger_alert(unique_ips, timestamp)
    
    def trigger_alert(self, ip_count, timestamp):
        """Trigger security alert"""
        alert = {
            "type": "DDoS_ATTACK_DETECTED",
            "timestamp": timestamp,
            "unique_ip_count": ip_count,
            "severity": "HIGH"
        }
        # Send to alert system
        self.send_alert(alert)
    
    def get_security_metrics(self):
        """Return security metrics"""
        return {
            "unique_ip_addresses": self.ip_tracker.estimate(),
            "unique_ports": self.port_tracker.estimate(),
            "attack_probability": self.calculate_attack_probability()
        }

import hashlib
import math
from collections import defaultdict

class HyperLogLog:
    def __init__(self, precision=14):
        """
        Initialize HyperLogLog
        
        Args:
            precision: Precision (4-16, default 14)
                      Higher precision = more accurate but more memory usage
        """
        self.precision = precision
        self.m = 2 ** precision  # Number of buckets
        self.registers = [0] * self.m
        
        # Correction factor
        self.alpha = self._calculate_alpha()
        
        # Hash function setup
        self.hash_func = hashlib.md5
    
    def _calculate_alpha(self):
        """Calculate correction factor"""
        alpha_values = {
            4: 0.673, 5: 0.697, 6: 0.709, 7: 0.715, 8: 0.718,
            9: 0.720, 10: 0.722, 11: 0.723, 12: 0.724, 13: 0.725,
            14: 0.726, 15: 0.727, 16: 0.728
        }
        return alpha_values.get(self.precision, 0.7213 / (1 + 1.079 / self.m))
    
    def add(self, element):
        """Add element"""
        # Calculate hash value
        hash_value = self._hash(element)
        
        # Calculate bucket index and value
        bucket_index = hash_value & (self.m - 1)
        value = self._count_leading_zeros(hash_value >> self.precision)
        
        # Update register
        self.registers[bucket_index] = max(self.registers[bucket_index], value)
    
    def _hash(self, element):
        """Calculate hash value"""
        hash_obj = self.hash_func(str(element).encode('utf-8'))
        return int(hash_obj.hexdigest()[:8], 16)
    
    def _count_leading_zeros(self, value):
        """Count leading zeros"""
        if value == 0:
            return 32 - self.precision
        
        leading_zeros = 0
        while (value & 0x80000000) == 0:
            leading_zeros += 1
            value <<= 1
        return leading_zeros
    
    def estimate(self):
        """Estimate cardinality"""
        # Calculate harmonic mean
        harmonic_mean = 0
        empty_registers = 0
        
        for register in self.registers:
            if register == 0:
                empty_registers += 1
            else:
                harmonic_mean += 2 ** (-register)
        
        # Calculate estimate
        raw_estimate = self.alpha * (self.m ** 2) / harmonic_mean
        
        # Small cardinality correction
        if raw_estimate <= 2.5 * self.m and empty_registers > 0:
            return self.m * math.log(self.m / empty_registers)
        
        # Large cardinality correction
        if raw_estimate > (2 ** 32) / 30:
            return -(2 ** 32) * math.log(1 - raw_estimate / (2 ** 32))
        
        return raw_estimate
    
    def merge(self, other):
        """Merge with another HyperLogLog"""
        if self.precision != other.precision:
            raise ValueError("Precision must be the same for merging")
        
        for i in range(self.m):
            self.registers[i] = max(self.registers[i], other.registers[i])
    
    def get_memory_usage(self):
        """Return memory usage (bytes)"""
        return self.m * 4  # Each register is 4 bytes

import multiprocessing as mp
from functools import partial

class ParallelHyperLogLog:
    def __init__(self, precision=14, num_workers=4):
        self.precision = precision
        self.num_workers = num_workers
        self.workers = []
        
        # Create HyperLogLog for each worker
        for _ in range(num_workers):
            self.workers.append(HyperLogLog(precision))
    
    def add_batch(self, elements):
        """Add batch elements (parallel processing)"""
        chunk_size = len(elements) // self.num_workers
        chunks = [elements[i:i + chunk_size] 
                 for i in range(0, len(elements), chunk_size)]
        
        # Parallel processing
        with mp.Pool(self.num_workers) as pool:
            worker_func = partial(self._worker_add_elements)
            pool.map(worker_func, zip(self.workers, chunks))
    
    def _worker_add_elements(self, worker_data):
        """Process elements per worker"""
        worker, elements = worker_data
        for element in elements:
            worker.add(element)
    
    def estimate(self):
        """Estimate cardinality after merging"""
        # Merge all workers
        merged = self.workers[0]
        for worker in self.workers[1:]:
            merged.merge(worker)
        
        return merged.estimate()

class StreamingHyperLogLog:
    def __init__(self, precision=14, window_size=3600):
        self.precision = precision
        self.window_size = window_size
        self.windows = {}
        self.current_time = 0
    
    def add_with_timestamp(self, element, timestamp):
        """Add element with timestamp"""
        # Calculate time window
        window_id = timestamp // self.window_size
        
        # Create new window
        if window_id not in self.windows:
            self.windows[window_id] = HyperLogLog(self.precision)
        
        # Add element
        self.windows[window_id].add(element)
        
        # Clean up old windows
        self._cleanup_old_windows(window_id)
    
    def _cleanup_old_windows(self, current_window):
        """Clean up old windows"""
        cutoff = current_window - 24  # Keep 24 hours
        old_windows = [w for w in self.windows.keys() if w < cutoff]
        for window in old_windows:
            del self.windows[window]
    
    def get_window_estimate(self, window_id):
        """Get cardinality estimate for specific window"""
        if window_id in self.windows:
            return self.windows[window_id].estimate()
        return 0
    
    def get_rolling_estimate(self, hours=1):
        """Get rolling window cardinality estimate"""
        current_window = self.current_time // self.window_size
        windows_to_merge = range(current_window - hours, current_window + 1)
        
        merged = HyperLogLog(self.precision)
        for window_id in windows_to_merge:
            if window_id in self.windows:
                merged.merge(self.windows[window_id])
        
        return merged.estimate()