The second local optimisation pass is only useful if deadcode did
something.  Stop running it redundantly when deadcode doesn't do
anything.
More debug stuff.
Whitelist Sub64F0x2 in the BDD constant folder, because I can't
be bothered to write constant folding rules for it.
We have to be a little bit careful when merging memory accesses to
make sure that we keep all of the accesses in a single thread in
order.  The rule is that the memory accesses issued by a single thread
must always be in strictly increasing order.

Suppose we want to merge two accesses:

lA:  LOAD maiA
     goto lC

lB:  LOAD maiB
     goto lC

Assume that the ordering is currently correct.  Call the set of
accesses issued by lC s(C), the set on any path to lA s(A)
and the set on any path to lB s(B).  Now we know:

-- x \in s(C) => x > maiA
-- x \in s(C) => x > maiB
   i.e. x \in s(C) => x > max(maiA, maiB)
-- x \in s(A) => x < maiA
-- x \in s(B) => x < maiB

If we merge A and B to produce D then the paths to D will be the union
of the paths to A and B.  Call the set of accesses on those paths s(D).
Then

x \in s(D) => x < maiA || x < maiB => x < max(maiA, maiB)

We can therefore safely use max(maiA, maiB) as the identifier for D,
but any other value is potentially dangerous.