AlgoScan

The `a == b` identity match for bitwise_xor_bytes folded `x ^ x` to the
biguint constant 0, which encodes as empty bytes. The AVM `b^` op
produces a zero-filled array of the same length as the inputs, so the
fold changed the observable byte-width of the result.

Remove the identity case; constant folding of literal xors is
unaffected (it correctly produces a zero-filled byte array of the
appropriate length).

The intrinsic simplifier folds biguint `x ^ x` to the integer constant
0 (which encodes as empty bytes), but the AVM `b^` op produces a
zero-filled byte array of the same length as the inputs.

The fold changes the observable byte-width of the result, breaking any
downstream code that depends on the length.

Visible in the destructured IR as `self_xor` reducing to `return 0b`
(empty bytes) regardless of the argument's length. The on-chain test
fails at -O1/-O2 where the fold triggers.

The `a == b` identity match for `div_floor` and `div_floor_bytes` folded
`x // x` to `1`, but this is only valid when `x != 0`. Since the AVM
panics on division by zero, the fold silently eliminates a runtime
error.

Both the uint64 and biguint intrinsic simplification paths fold `x // x`
to `1` unconditionally, without considering that `x` may be zero.

The AVM panics on division by zero, so the fold silently eliminates
a runtime error: calling self_div(0) returns 1 instead of halting.

The incorrect optimization is visible in the destructured IR where the
subroutine body is reduced to `return 1u` / `return 1b` regardless of
the argument. The on-chain tests fail at -O1 and -O2 (where the fold
triggers) but pass at -O0 (where the division is preserved).

The constant-folding branch for div_floor_bytes had no guard against a
zero divisor, crashing the compiler with a ZeroDivisionError. Now
guarded with `if b_const != 0`, matching the existing mod_bytes case.

The intrinsic simplifier attempts to constant-fold BigUInt floor division
without guarding against a zero divisor, crashing the compiler with a
Python ZeroDivisionError.

compilation at -O1/-O2 crashes with:
  ZeroDivisionError: division by zero

Remove the assertion in biguint_bytes_eval that crashes on >64 byte
values. Instead, _get_biguint_constant now returns None for the integer
value when the bytes constant exceeds 64 bytes, preventing constant
folding while still allowing valid IR to flow through.

Remove the assertion in biguint_bytes_eval that crashes on >64 byte
values. Instead, _get_biguint_constant now returns None for the integer
value when the bytes constant exceeds 64 bytes, preventing constant
folding while still allowing valid IR to flow through.

BigUInt constants that exceed 64 bytes (e.g. 2**512) cause an
AssertionError in biguint_bytes_eval during intrinsic simplification.

The crash is triggered when a first constant fold produces a >64 byte
result, and a subsequent optimization pass attempts to simplify a
binary op using that result.

compilation at -O1/-O2 crashes with:
  AssertionError: Biguints must be 64 bytes or less