typedef struct {
    void *allocation;
    timestamp_t birth_time;
    size_t size;
} allocation_record_t;

typedef struct {
    uint64_t age_buckets[MAX_AGE_BUCKETS];
    uint64_t total_allocations;
    uint64_t total_deallocations;
    double mean_lifetime;
    double variance;
} age_distribution_t;

// Age tracking infrastructure
struct gencount_tracker {
    hash_table_t *active_allocations;
    age_distribution_t *site_distributions;
    uint64_t current_time;
    double anomaly_threshold;
};

// Hook allocation
void gencount_on_malloc(void *ptr, size_t size, void *site) {
    allocation_record_t record = {
        .allocation = ptr,
        .birth_time = get_timestamp(),
        .size = size
    };
    hash_table_insert(tracker->active_allocations, ptr, record);
}

// Hook deallocation
void gencount_on_free(void *ptr) {
    allocation_record_t *record = hash_table_lookup(tracker->active_allocations, ptr);
    if (record) {
        uint64_t age = get_timestamp() - record->birth_time;
        update_age_distribution(record->site, age);
        hash_table_remove(tracker->active_allocations, ptr);
    }
}

void update_age_distribution(void *site, uint64_t age) {
    age_distribution_t *dist = get_site_distribution(site);
    
    // Update age histogram
    size_t bucket = age_to_bucket(age);
    dist->age_buckets[bucket]++;
    
    // Update running statistics
    update_mean_variance(dist, age);
    
    // Trigger anomaly detection if enough samples
    if (dist->total_deallocations % ANALYSIS_INTERVAL == 0) {
        check_for_anomaly(site, dist);
    }
}

bool check_for_anomaly(void *site, age_distribution_t *dist) {
    // Calculate expected exponential distribution
    double lambda = 1.0 / dist->mean_lifetime;
    
    // Perform statistical tests
    double chi_squared = calculate_chi_squared(dist, lambda);
    double p_value = chi_squared_p_value(chi_squared, dist->bucket_count - 1);
    
    if (p_value < SIGNIFICANCE_LEVEL) {
        report_anomaly(site, dist, p_value);
        return true;
    }
    
    return false;
}

void report_anomaly(void *site, age_distribution_t *dist, double p_value) {
    leak_report_t report = {
        .allocation_site = site,
        .confidence = 1.0 - p_value,
        .mean_lifetime = dist->mean_lifetime,
        .total_allocations = dist->total_allocations,
        .estimated_leak_rate = calculate_leak_rate(dist)
    };
    
    add_to_leak_report_queue(report);
}

// Efficient age bucket representation
#define MAX_AGE_BUCKETS 64
#define AGE_BUCKET_SCALE_LOG2 10  // 1024 time units per bucket

typedef struct {
    // Logarithmic age buckets for efficient storage
    uint32_t buckets[MAX_AGE_BUCKETS];
    
    // Statistical moments
    double sum_ages;
    double sum_squared_ages;
    uint64_t sample_count;
    
    // Anomaly detection state
    double last_chi_squared;
    timestamp_t last_analysis;
    bool is_anomalous;
} compact_age_distribution_t;

static inline uint64_t calculate_age(timestamp_t birth, timestamp_t death) {
    // Handle timestamp wraparound
    if (death < birth) {
        return (TIMESTAMP_MAX - birth) + death + 1;
    }
    return death - birth;
}

static inline size_t age_to_bucket(uint64_t age) {
    // Logarithmic bucketing for wide age range
    if (age == 0) return 0;
    
    size_t bucket = 63 - __builtin_clzll(age);
    return (bucket < MAX_AGE_BUCKETS) ? bucket : MAX_AGE_BUCKETS - 1;
}

void update_distribution_efficient(compact_age_distribution_t *dist, uint64_t age) {
    // Update bucket
    size_t bucket = age_to_bucket(age);
    dist->buckets[bucket]++;
    
    // Update statistical moments (Welford's algorithm)
    dist->sample_count++;
    double delta = age - (dist->sum_ages / dist->sample_count);
    dist->sum_ages += age;
    dist->sum_squared_ages += delta * (age - (dist->sum_ages / dist->sample_count));
}

// Per-allocation overhead
sizeof(allocation_record_t) = 24 bytes  // ptr + timestamp + size

// Per-site overhead
sizeof(compact_age_distribution_t) = 296 bytes  // buckets + stats + state

// Hash table overhead (approximation)
hash_overhead = load_factor * (sizeof(void*) + sizeof(hash_entry))

// Total overhead estimate
total_overhead = (active_allocations * 24) + (unique_sites * 296) + hash_overhead

// Complete age tracking implementation
static void track_allocation_age(void *ptr, size_t size, void *site) {
    if (!gencount_enabled) return;
    
    allocation_record_t record = {
        .allocation = ptr,
        .birth_time = rdtsc_timestamp(),  // Low-overhead timestamp
        .size = size
    };
    
    // Use lock-free hash table for performance
    lockfree_hash_insert(&active_allocations, ptr, record);
    
    // Update allocation count for site
    atomic_increment(&site_stats[site].allocation_count);
}

static void track_deallocation_age(void *ptr) {
    allocation_record_t record;
    if (lockfree_hash_remove(&active_allocations, ptr, &record)) {
        uint64_t age = rdtsc_timestamp() - record.birth_time;
        void *site = get_allocation_site(ptr);  // From stack trace cache
        
        update_age_distribution_atomic(site, age);
        
        // Periodic anomaly detection (amortized cost)
        if (should_run_analysis(site)) {
            schedule_anomaly_analysis(site);
        }
    }
}

// Statistical analysis implementation
double calculate_exponential_fit(compact_age_distribution_t *dist) {
    double mean_age = dist->sum_ages / dist->sample_count;
    double lambda = 1.0 / mean_age;
    
    // Calculate chi-squared statistic
    double chi_squared = 0.0;
    double cumulative_expected = 0.0;
    
    for (int i = 0; i < MAX_AGE_BUCKETS; i++) {
        double bucket_min_age = (1ULL << i);
        double bucket_max_age = (1ULL << (i + 1));
        
        // Expected count for exponential distribution
        double expected_prob = exp(-lambda * bucket_min_age) - exp(-lambda * bucket_max_age);
        double expected_count = expected_prob * dist->sample_count;
        
        if (expected_count > 5.0) {  // Chi-squared validity requirement
            double observed = dist->buckets[i];
            double diff = observed - expected_count;
            chi_squared += (diff * diff) / expected_count;
        }
    }
    
    return chi_squared;
}

// Anomaly detection with multiple statistical tests
bool detect_statistical_anomaly(void *site, compact_age_distribution_t *dist) {
    if (dist->sample_count < MIN_SAMPLES_FOR_ANALYSIS) {
        return false;
    }
    
    // Test 1: Chi-squared goodness of fit
    double chi_squared = calculate_exponential_fit(dist);
    double chi_p_value = chi_squared_p_value(chi_squared, effective_buckets - 1);
    
    // Test 2: Heavy tail detection
    double tail_weight = calculate_tail_weight(dist);
    bool heavy_tail = tail_weight > TAIL_WEIGHT_THRESHOLD;
    
    // Test 3: Variance-to-mean ratio (overdispersion)
    double variance = calculate_variance(dist);
    double mean = dist->sum_ages / dist->sample_count;
    double overdispersion = variance / (mean * mean);  // Coefficient of variation squared
    
    // Combined decision with multiple criteria
    bool is_anomaly = (chi_p_value < SIGNIFICANCE_LEVEL) && 
                     (heavy_tail || (overdispersion > OVERDISPERSION_THRESHOLD));
    
    if (is_anomaly) {
        log_anomaly_detection(site, chi_p_value, tail_weight, overdispersion);
    }
    
    return is_anomaly;
}

// Integration with existing memory allocators
void gencount_malloc_hook(void *ptr, size_t size) {
    if (gencount_should_track()) {
        void *site = get_call_site(2);  // Skip malloc wrapper
        track_allocation_age(ptr, size, site);
    }
}

void gencount_free_hook(void *ptr) {
    if (ptr && gencount_enabled) {
        track_deallocation_age(ptr);
    }
}

// LD_PRELOAD wrapper
void *malloc(size_t size) {
    void *ptr = real_malloc(size);
    gencount_malloc_hook(ptr, size);
    return ptr;
}

void free(void *ptr) {
    gencount_free_hook(ptr);
    real_free(ptr);
}

// Pattern: Objects that live much longer than expected
void detect_long_lived_pattern(compact_age_distribution_t *dist) {
    double mean_age = dist->sum_ages / dist->sample_count;
    double p99_threshold = calculate_percentile(dist, 0.99);
    
    // Flag if significant portion lives beyond expected lifetime
    if (p99_threshold > (mean_age * LONG_LIVED_MULTIPLIER)) {
        flag_pattern(LONG_LIVED_OBJECTS, p99_threshold / mean_age);
    }
}

// Pattern: Distribution tail growing over time
typedef struct {
    compact_age_distribution_t snapshots[MAX_SNAPSHOTS];
    size_t current_snapshot;
    timestamp_t snapshot_interval;
} temporal_distribution_t;

void detect_growing_tail(temporal_distribution_t *temporal) {
    if (temporal->current_snapshot < 2) return;
    
    // Compare recent snapshots
    double recent_tail = calculate_tail_weight(&temporal->snapshots[temporal->current_snapshot]);
    double older_tail = calculate_tail_weight(&temporal->snapshots[temporal->current_snapshot - 1]);
    
    double growth_rate = (recent_tail - older_tail) / older_tail;
    
    if (growth_rate > TAIL_GROWTH_THRESHOLD) {
        flag_pattern(GROWING_DISTRIBUTION, growth_rate);
    }
}

// Pattern: Sites with unusual statistical properties
void detect_anomalous_sites(void) {
    site_statistics_t *stats = collect_site_statistics();
    
    for (size_t i = 0; i < stats->site_count; i++) {
        compact_age_distribution_t *dist = &stats->distributions[i];
        
        // Calculate z-score compared to global distribution
        double site_mean = dist->sum_ages / dist->sample_count;
        double global_mean = stats->global_mean_age;
        double global_stddev = stats->global_stddev_age;
        
        double z_score = (site_mean - global_mean) / global_stddev;
        
        if (abs(z_score) > Z_SCORE_THRESHOLD) {
            flag_anomalous_site(stats->sites[i], z_score);
        }
    }
}

// Pattern: Sites that are statistical outliers
void detect_statistical_outliers(site_statistics_t *stats) {
    // Use Grubbs' test for outlier detection
    double *mean_ages = malloc(stats->site_count * sizeof(double));
    
    for (size_t i = 0; i < stats->site_count; i++) {
        mean_ages[i] = stats->distributions[i].sum_ages / stats->distributions[i].sample_count;
    }
    
    double population_mean = calculate_mean(mean_ages, stats->site_count);
    double population_stddev = calculate_stddev(mean_ages, stats->site_count);
    
    for (size_t i = 0; i < stats->site_count; i++) {
        double grubbs_statistic = abs(mean_ages[i] - population_mean) / population_stddev;
        double grubbs_critical = grubbs_critical_value(stats->site_count, SIGNIFICANCE_LEVEL);
        
        if (grubbs_statistic > grubbs_critical) {
            flag_statistical_outlier(stats->sites[i], grubbs_statistic);
        }
    }
    
    free(mean_ages);
}

// Measured overhead for typical applications
struct overhead_analysis {
    size_t baseline_heap_size;      // 256MB typical
    size_t tracking_overhead;       // 15MB (6%)
    size_t distribution_overhead;   // 2MB (0.8%)
    size_t hash_table_overhead;     // 8MB (3.1%)
    size_t total_overhead;          // 25MB (9.8%)
};

// Combine statistical analysis with sampling for better performance
if (should_sample_allocation(ptr)) {
    track_allocation_age(ptr, size, site);
}

// Use both age distribution and growth patterns
bool is_leak = detect_age_anomaly(site) && detect_growth_pattern(site);

// Complex statistical computation requirements
double calculate_anderson_darling_statistic(compact_age_distribution_t *dist) {
    // Requires numerical integration and special functions
    double *sorted_ages = sort_age_samples(dist);
    double n = dist->sample_count;
    double sum = 0.0;
    
    for (size_t i = 0; i < n; i++) {
        double Fi = exponential_cdf(sorted_ages[i], lambda);
        double term1 = (2*i + 1) * log(Fi);
        double term2 = (2*(n-i) - 1) * log(1 - Fi);
        sum += term1 + term2;
    }
    
    return -n - sum / n;
}

// Hot path optimization requirements
static inline void fast_age_update(void *site, uint64_t age) {
    // Must be extremely fast - called on every deallocation
    site_stats_t *stats = get_site_stats_fast(site);
    
    // Use CPU cache-friendly updates
    __builtin_prefetch(&stats->buckets[age_to_bucket(age)], 1, 3);
    
    // Atomic increment without locks
    atomic_increment_relaxed(&stats->buckets[age_to_bucket(age)]);
    
    // Amortized statistical analysis
    if (unlikely(should_analyze(stats))) {
        schedule_background_analysis(site, stats);
    }
}

struct tuning_parameters {
    double significance_level;     // Type I error rate
    double effect_size_threshold;  // Practical significance
    size_t min_sample_size;       // Statistical power
    double tail_weight_threshold; // Heavy tail detection
    size_t analysis_interval;     // Performance vs accuracy
};

// Application-specific tuning
struct tuning_parameters web_server_params = {
    .significance_level = 0.01,      // Low false positive rate
    .effect_size_threshold = 0.5,    // Medium effect size
    .min_sample_size = 1000,         // Reliable statistics
    .tail_weight_threshold = 0.1,    // Sensitive tail detection
    .analysis_interval = 10000       // Frequent analysis
};

// Dynamic threshold adjustment based on application behavior
void adapt_thresholds(application_profile_t *profile) {
    if (profile->allocation_rate > HIGH_ALLOCATION_THRESHOLD) {
        // High-throughput applications: stricter thresholds
        tuning.significance_level *= 0.5;
        tuning.min_sample_size *= 2;
    }
    
    if (profile->false_positive_rate > ACCEPTABLE_FP_RATE) {
        // Too many false positives: relax detection
        tuning.significance_level *= 0.8;
        tuning.effect_size_threshold *= 1.2;
    }
}

// Simplified production-ready version
struct production_gencount {
    // Reduced memory footprint
    uint16_t age_buckets[16];  // Coarser age bins
    
    // Simple statistics
    uint32_t sample_count;
    uint64_t sum_ages;
    
    // Binary anomaly flag
    bool is_anomalous;
    timestamp_t last_analysis;
};

// Reduce overhead with intelligent sampling
bool should_track_allocation(void *site, size_t size) {
    // Higher sampling rate for larger allocations
    double sampling_rate = min(1.0, size / (double)LARGE_ALLOCATION_THRESHOLD);
    
    // Higher sampling rate for previously anomalous sites
    if (is_site_anomalous(site)) {
        sampling_rate *= ANOMALOUS_SITE_MULTIPLIER;
    }
    
    return (random_double() < sampling_rate);
}

// Use ML models for better pattern recognition
struct ml_enhanced_gencount {
    neural_network_t *leak_classifier;
    feature_vector_t *distribution_features;
    double prediction_confidence;
};

double predict_leak_probability(compact_age_distribution_t *dist) {
    feature_vector_t features = extract_distribution_features(dist);
    return neural_network_predict(leak_classifier, &features);
}

// Leverage hardware features for performance
void hardware_optimized_tracking(void) {
    // Use Intel CET for efficient stack trace capture
    void *site = capture_call_site_cet();
    
    // Use hardware timestamps
    uint64_t timestamp = __rdtsc();
    
    // Use SIMD for statistical calculations
    __m256d ages = _mm256_load_pd(age_array);
    __m256d moments = _mm256_dp_pd(ages, ages, 0xFF);
}