fn reference_ports(values: &[PORT_TYPE]) -> Result<i64, Fault> {
    let fault = &FaultInfo { message: "integer arithmetic fault", source: "Rust reference", line: 0, column: 0 };
    let mut total = 0i64;
    for value in values {
        let value = value.field0.checked_add(1).ok_or(fault)?;
        total = total.checked_add(value).ok_or(fault)?;
    }
    Ok(total)
}

// 两处溢出保留各自来源；原单一错误参照仍用于观察诊断语义的成本。
fn reference_ports_distinct_faults(values: &[PORT_TYPE]) -> Result<i64, Fault> {
    let mut total = 0i64;
    for value in values {
        let adjusted = value.field0.checked_add(1).ok_or(&FaultInfo {
            message: "integer arithmetic fault", source: "Rust reference", line: 1, column: 1,
        })?;
        total = total.checked_add(adjusted).ok_or(&FaultInfo {
            message: "integer overflow", source: "Rust reference", line: 2, column: 1,
        })?;
    }
    Ok(total)
}

// Port 只允许 1..=65535，加一不可能溢出；累计仍按 Int 合同检查。
fn reference_ports_bounded(values: &[PORT_TYPE]) -> Result<i64, Fault> {
    let mut total = 0i64;
    for value in values {
        total = total.checked_add(value.field0.wrapping_add(1)).ok_or(&FaultInfo {
            message: "integer overflow", source: "Rust reference", line: 2, column: 1,
        })?;
    }
    Ok(total)
}

const SCALE: [u8; 16] = [34, 7, 192, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0];

fn reference_rates(values: &[RATE_TYPE]) -> Result<Decimal, Fault> {
    let fault = &FaultInfo { message: "decimal arithmetic fault", source: "Rust reference", line: 0, column: 0 };
    let scale = dec::Decimal128::from_be_bytes(SCALE);
    let mut context = dec::Context::<dec::Decimal128>::default();
    let mut total = dec::Decimal128::ZERO;
    for value in values {
        context.clear_status();
        let value = context.mul(dec::Decimal128::from_be_bytes(value.field0.to_be_bytes()), scale);
        if !value.is_finite() || context.status().overflow() || context.status().invalid_operation() { return Err(fault); }
        context.clear_status();
        total = context.add(total, value);
        if !total.is_finite() || context.status().overflow() || context.status().invalid_operation() { return Err(fault); }
    }
    Ok(Decimal::from_be_bytes(total.to_be_bytes()))
}

fn main() {
    assert_eq!(Decimal::parse("100.0").unwrap().to_be_bytes(), SCALE);
    for values in [vec![], vec![1], vec![65535], vec![1, 65535], vec![32768, 32767]] {
        let ports = values.into_iter().map(|field0| PORT_TYPE { field0 }).collect::<Vec<_>>();
        assert_eq!(GENERATED_TOTAL(&ports).map_err(|fault| fault.message), reference_ports_distinct_faults(&ports).map_err(|fault| fault.message));
        assert_eq!(GENERATED_TOTAL(&ports).map_err(|fault| fault.message), reference_ports_bounded(&ports).map_err(|fault| fault.message));
    }
    println!("case,sample,implementation,elapsed_ns,checksum");
    let ports = (0..64).map(|index| PORT_TYPE { field0: index * 1000 + 1 }).collect::<Vec<_>>();
    compare("range_int", &ports, 100_000, GENERATED_TOTAL, reference_ports, |value| *value as u64);
    compare("range_int_distinct_faults", &ports, 100_000, GENERATED_TOTAL, reference_ports_distinct_faults, |value| *value as u64);
    compare("range_int_bounded", &ports, 100_000, GENERATED_TOTAL, reference_ports_bounded, |value| *value as u64);
    let rates = (0..32).map(|index| RATE_TYPE { field0: Decimal::parse(&format!("0.{index:02}")).unwrap() }).collect::<Vec<_>>();
    assert_eq!(GENERATED_RATES(&rates).unwrap().to_be_bytes(), reference_rates(&rates).unwrap().to_be_bytes());
    compare("range_decimal", &rates, 5_000, GENERATED_RATES, reference_rates, |value| u64::from(value.to_be_bytes()[15]));
}