编号从255回到0，是旧消息又来了，还是新消息？

"""RFC 1982 arithmetic teaching model with explicit half-range ambiguity."""
import json


def validate(value, bits):
    if type(bits) is not int or bits < 2 or type(value) is not int or not 0 <= value < (1 << bits):
        raise ValueError("value must fit the declared serial number width")


def relation(candidate, reference, bits=8):
    validate(candidate, bits)
    validate(reference, bits)
    space = 1 << bits
    distance = (candidate - reference) % space
    if distance == 0:
        return "equal"
    if distance == space // 2:
        return "undefined-half-range"
    return "newer" if distance < space // 2 else "older"


def increment(value, amount, bits=8):
    validate(value, bits)
    if type(amount) is not int or not 0 <= amount < (1 << (bits - 1)):
        raise ValueError("RFC 1982 increment must be less than half the serial space")
    return (value + amount) % (1 << bits)


def order_with_anchor(values, anchor, bits=8):
    validate(anchor, bits)
    for value in values:
        validate(value, bits)
        if (value - anchor) % (1 << bits) >= (1 << (bits - 1)):
            raise ValueError("every value must be inside the declared forward half-window")
    return sorted(values, key=lambda value: (value - anchor) % (1 << bits))


def reference_relation(a, b, bits):
    # Written directly as the RFC's ordinary-integer comparison conditions.
    half = 1 << (bits - 1)
    if a == b:
        return "equal"
    if (a < b and b - a > half) or (a > b and a - b < half):
        return "newer"
    if (a < b and b - a < half) or (a > b and a - b > half):
        return "older"
    return "undefined-half-range"


def main():
    checks = 0
    inverse = {"newer": "older", "older": "newer", "equal": "equal",
               "undefined-half-range": "undefined-half-range"}
    for bits in range(2, 9):
        for a in range(1 << bits):
            for b in range(1 << bits):
                result = relation(a, b, bits)
                assert result == reference_relation(a, b, bits)
                assert inverse[result] == relation(b, a, bits)
                checks += 2
    assert increment(250, 10) == 4
    checks += 1
    try:
        increment(10, 128)
        raise AssertionError("half-range increment accepted")
    except ValueError:
        checks += 1
    try:
        order_with_anchor([0, 128], 0)
        raise AssertionError("ambiguous window accepted")
    except ValueError:
        checks += 1
    values = [0, 251, 1, 250]
    ordered = order_with_anchor(values, 250)
    assert ordered == [250, 251, 0, 1]
    checks += 1
    cyclic = [relation(100, 0), relation(200, 100), relation(0, 200)]
    assert cyclic == ["newer"] * 3
    checks += 1
    print(json.dumps({"checks_passed": checks, "increment_250_by_10": increment(250, 10),
                      "candidate_0_reference_255": relation(0, 255),
                      "candidate_255_reference_0": relation(255, 0),
                      "candidate_128_reference_0": relation(128, 0),
                      "ordinary_numeric_sort": sorted(values), "anchored_order": ordered,
                      "cyclic_comparisons_100_after_0_200_after_100_0_after_200": cyclic,
                      "boundary": "8-bit illustration; finite serial values do not identify epochs"}, indent=2))


if __name__ == "__main__":
    main()