diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index fb94973c056..cbf7d588757 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -32,8 +32,8 @@ name: Nightly # for the full set, so it rotates (see sh/rs/mutants.sh). # # `route-proof` type-checks the route rule's convergence proof with Agda, about -# two minutes. The Rust side of its binding, the generated `Vectors.agda`, is -# checked current by every PR's tests; the proof itself only changes when the +# two minutes. The Rust side of its binding, the generated `Vectors.agda` and +# `ClaimVectors.agda`, is checked current by every PR's tests; the proof itself only changes when the # rule does, which review checks. # # `quic-interop` runs moq-quic against other QUIC stacks through the QUIC diff --git a/quest/m2/multicast/README.md b/quest/m2/multicast/README.md index 79795f8229d..7ac46a35893 100644 --- a/quest/m2/multicast/README.md +++ b/quest/m2/multicast/README.md @@ -38,7 +38,6 @@ children, [the uncovered cases](/quest/m2/multicast/accept.md), [route layer acceptance](/quest/m2/cluster-routes/acceptance.md) retiring the lite-06 mitigations. After the cut come warmth's wire ([cache-aware routing](/quest/m3/cache-routing/README.md)), -[the proof binding](/quest/m3/route-proof-binding.md), [route health](/quest/m3/route-health/README.md), and [outbound federation](/quest/m3/cluster-routing/federation.md). diff --git a/quest/m3/route-proof-binding.md b/quest/m3/route-proof-binding.md deleted file mode 100644 index c36dd453a0b..00000000000 --- a/quest/m3/route-proof-binding.md +++ /dev/null @@ -1,56 +0,0 @@ -# [L] Bind the route proof to the router - -## Goal - -The route proof's Rust binding runs `route::relay::Router`'s own functions, -so `just test route-proof` checks the router that ships. - -## Plan - -Found 2026-11-16 by [the proof](https://github.com/moq-dev/moq/pull/8904) -against the prototype; proposed by -[moq-dev/moq#9053](https://github.com/moq-dev/moq/pull/9053). - -Decided 2026-11-18 (maintainer, on -[moq-dev/moq#9053](https://github.com/moq-dev/moq/pull/9053#issuecomment-6975349236)): -✅ kept, and it follows the lite-07 cut, since none of it is wire; the -chain change, which is, landed before the cut in -[moq-dev/moq#9082](https://github.com/moq-dev/moq/pull/9082) (rejected: the -whole binding before the cut; dropping the chain change). - -- Order equal routes the same way in the proof and the router: the proof - orders them by the neighbour, the prototype by its simulation's node index, - and `route::relay::Router::reselect` by rank (drain, priority, cost), then - an unmarked route first, then the next hop in use, then path length, then - the sender's Node ID, then the neighbour key. Ordering by the neighbour's - Node ID alone matches only if the router adopts it; otherwise give the - binding the router's whole key. -- A claim the router adopts across a marked link, or one carrying the - `Marked` flag, is announced under the node's marked Node ID: its own Relay - and Start with the typed Marked field set, the same process holding no - session ([moq-dev/moq#9053](https://github.com/moq-dev/moq/pull/9053)). - The route to that identity is the node's own: marked, at cost 0, with the - Path `[marked identity, node]`, whose marked hop counts toward the 32. The - claim keeps its own cost, the giver's claim cost plus the adopting link's, - and its own chain, but no route Path of its own. Model both, or say why the - proof's single identity per node covers them. -- Move the binding to the router: point `route/tests/algebra.rs` and - `route/tests/sticky.rs` at the router's own functions for a node's own - route, sending a route on, taking one in, ordering candidates, and listing - them, regenerate `Vectors.agda`, and run `just test route-proof`. The claim - instance first needs the router's precedence as its leading keys: a claim - exactly at its path before a broader one shown there, then the newest - epoch, decided over every claim of the Instance at that path whether or not - a route reaches it, and only then the route joined with the claim's drain, - priority, and cost. Neither the mechanized instance nor its Rust vectors - cover precedence yet. Bind the chain as - [moq-dev/moq#9082](https://github.com/moq-dev/moq/pull/9082) left it: the - relays a claim entered or left a routing domain by, a relay across a grant - refusing a chain that names a relay twice once it appends itself, and no - check inside a domain (the proof README's "What this does not give"). - -Public API: none. Wire: none. - -## Related - -- [Cache-aware multicast](/quest/m2/multicast/README.md) - the route layer it proves diff --git a/rs/moq-net/src/route/relay.rs b/rs/moq-net/src/route/relay.rs index 62f1e174773..a92faf34b37 100644 --- a/rs/moq-net/src/route/relay.rs +++ b/rs/moq-net/src/route/relay.rs @@ -112,11 +112,10 @@ pub(crate) struct Hop { } /// A route's rank, lower first: draining, then the lowest priority, then the cost. -type Rank = (bool, Reverse, Metric); +pub(crate) type Rank = (bool, Reverse, Metric); -/// How claims of one precedence order, lower first: the rank of the route and the claim -/// together, then the fewer relays that took the claim on its way here, and the claimant. -type ClaimOrder = (Rank, usize, NodeId); +/// How claims of one precedence order, as [`claim_order`] keys them. +pub(crate) type ClaimOrder = (Rank, bool, usize, NodeId); /// What a route says. #[derive(Clone, Debug, PartialEq, Eq)] @@ -134,9 +133,93 @@ pub(crate) struct Offer { } impl Offer { - fn rank(&self) -> Rank { + pub(crate) fn rank(&self) -> Rank { (self.draining, Reverse(self.priority), self.cost) } + + /// The route node `me` offers to its own identity `origin`, itself or its marked one, + /// over a link it marked when `upstream`. The marked identity's route leads through + /// `me`, as if learned on a marked link, so it is never sent over another. + pub(crate) fn own(me: NodeId, origin: NodeId, upstream: bool) -> Option { + let hop = Hop { node: me, session: 0 }; + let path: Arc<[Hop]> = match origin.marked { + true => Arc::new([ + Hop { + node: origin, + session: 0, + }, + hop, + ]), + false => Arc::new([hop]), + }; + let own = Self { + path, + draining: false, + priority: i8::MAX, + cost: 0, + marked: origin.marked, + }; + (!(own.marked && upstream)).then_some(own) + } + + /// This route, as node `me` holds it over its session `session`, sent on to routing + /// neighbour `to` over a link `me` marked when `upstream`: never to a relay already on + /// its path, or from one marked link to another. + pub(crate) fn onward(&self, me: NodeId, session: u64, to: NodeId, upstream: bool) -> Option { + if names(&self.path, to.relay) || (self.marked && upstream) { + return None; + } + let path: Arc<[Hop]> = self.path.iter().copied().chain([Hop { node: me, session }]).collect(); + Some(Self { path, ..self.clone() }) + } +} + +/// Everything a node holds that decides whether it uses a route a neighbour offers, and +/// how it ranks it. +pub(crate) struct Here<'a> { + /// Per pair of relays, the highest session known closed. + pub closed: &'a BTreeMap<(Id, Id), (u64, u64)>, + /// Closed sessions a live heard route still names. + pub dead: &'a BTreeMap, + /// Nodes named as draining. + pub draining: &'a BTreeSet, +} + +impl Here<'_> { + /// `offer`, heard on `port` from a neighbour that sent GOAWAY when `draining`, as it + /// stands here: priced and ranked over the link. `None` for one this node never uses: + /// at the longest path, through a session known closed, or past the metric. + pub fn arrive(&self, port: &Port, draining: bool, offer: &Offer) -> Option { + let floored = pairs(&offer.path).any(|(pair, at)| self.closed.get(&pair).is_some_and(|highest| at <= *highest)); + if offer.path.len() >= MAX_HOPS || floored || offer.path.iter().any(|hop| self.dead.contains_key(hop)) { + return None; + } + Some(Offer { + path: offer.path.clone(), + draining: offer.draining || draining || offer.path.iter().any(|hop| self.draining.contains(&hop.node)), + priority: offer.priority.min(port.priority), + // A route no link could extend is past every other, so it is never used. + cost: offer.cost.checked_add(port.cost)?, + marked: offer.marked || port.upstream, + }) + } +} + +/// How a candidate route orders, lower first: rank, then one with no marked link on its +/// path, which more neighbours may be sent, the next hop in use (`current`), the shorter +/// path, the neighbour's Node ID, and its session. +pub(crate) fn order(best: &Best, current: Option) -> Order { + let (draining, priority, cost) = best.offer.rank(); + ( + draining, + priority, + cost, + best.offer.marked, + current != Some(best.via), + best.offer.path.len(), + best.offer.path.last().expect("a heard route names its sender").node, + best.via, + ) } /// The Node ID a node announces what it took over a marked link under. @@ -182,7 +265,7 @@ fn pairs(path: &[Hop]) -> impl Iterator + '_ { /// The pair of relays `hop`'s session joins, as the floor files it, and where the session /// stands in that pair's order. -fn floor_of(hop: Hop, far: NodeId) -> ((Id, Id), (u64, u64)) { +pub(crate) fn floor_of(hop: Hop, far: NodeId) -> ((Id, Id), (u64, u64)) { ((hop.node.relay, far.relay), (hop.node.start, hop.session)) } @@ -223,18 +306,110 @@ impl Claim { (self.draining, Reverse(self.priority), self.cost) } - fn lowered(&self, by: u64) -> Self { + pub(crate) fn lowered(&self, by: u64) -> Self { Self { item: self.item.lowered(by), ..self.clone() } } + + /// The rank and mark of this claim, announced by another node of this node's routing + /// domain, joined with `route`, this node's route to that node. + fn joined(&self, route: &Offer) -> (Rank, bool) { + let (draining, Reverse(priority), cost) = route.rank(); + let rank = ( + draining || self.draining, + Reverse(priority.min(self.priority)), + cost.saturating_add(self.cost), + ); + (rank, self.marked || route.marked) + } + + /// This claim, announced by another node of this node's routing domain, as it stands + /// here over `route`, this node's route to that node. + pub(crate) fn over(&self, route: &Offer) -> Self { + let ((draining, Reverse(priority), cost), marked) = self.joined(route); + Self { + draining, + priority, + cost, + marked, + ..self.clone() + } + } + + /// This claim, as it stands at relay `me`, told across a grant over a link `me` marked + /// when `upstream`: the chain names `me` as the claim leaves its routing domain, unless + /// it does not `forward`. `None` where it is told to no one: one that crossed a marked + /// link goes over no other, and one that would reach the longest path goes nowhere. + pub(crate) fn exported(&self, me: Id, forwards: bool, upstream: bool) -> Option { + if upstream && self.marked { + return None; + } + let mut claim = self.clone(); + stamp(&mut claim.chain, me, forwards); + (claim.chain.len() < MAX_HOPS).then_some(claim) + } + + /// This claim, given by a neighbour on `port`, as relay `me` takes it: priced over the + /// link, marked if `port` is, and its chain naming `me` as it enters `me`'s routing + /// domain. `None` where `me` refuses it: the chain, with `me` appended, names a relay + /// twice or reaches the longest path. + pub(crate) fn adopted(&self, me: Id, forwards: bool, port: &Port) -> Option { + if !takes(&self.chain, me, forwards) { + return None; + } + let mut claim = self.clone(); + // Saturating, as `model::origin`'s claim cost does, so a claim's cost never + // decides whether it can serve. + claim.cost = claim.cost.saturating_add(port.cost); + claim.priority = claim.priority.min(port.priority); + claim.marked |= port.upstream; + stamp(&mut claim.chain, me, forwards); + Some(claim) + } +} + +/// Whether relay `me` takes a claim whose chain is `chain` from a peer it exchanges no +/// routes with. One naming `me`, or any relay twice, left the routing domain of that relay +/// and came back to it, and one `me` would carry to the longest path is never taken, as a +/// route past the metric is never used. +fn takes(chain: &[Id], me: Id, forwards: bool) -> bool { + // At most 31 relays (`well_built`), so a quadratic scan beats allocating a set. + let once = (chain.iter().enumerate()).all(|(at, relay)| *relay != me && !chain[..at].contains(relay)); + once && chain.len() + usize::from(forwards) < MAX_HOPS +} + +/// Name relay `me` at the end of a claim's chain as the claim enters or leaves its routing +/// domain, unless it ends the chain already, as a relay that adopted a claim across one +/// grant and exports it across the next does, or it does not `forward`. +fn stamp(chain: &mut Vec, me: Id, forwards: bool) { + if forwards && chain.last() != Some(&me) { + chain.push(me); + } +} + +/// How claims of one precedence order at a node, lower first: the rank of the claim +/// joined with `route`, the route to its announcer `origin`, or none for the node's own; +/// then one no marked link reached, which more neighbours may be told, as a route is +/// chosen; the fewer relays that took it on its way here; and the claimant. It reads only +/// the route's rank and mark, which [`Ways`] records, so a route change that moves the +/// closest claim is logged ([`Router::relog`]). +pub(crate) fn claim_order(claim: &Claim, route: Option<&Offer>, origin: NodeId) -> ClaimOrder { + let (rank, marked) = match route { + Some(route) => claim.joined(route), + None => (claim.rank(), claim.marked), + }; + // Counted as the relays that took the claim on its way here: this node's own claim + // names it already, and another's lacks the step from here to its announcer. + let taken = claim.chain.len() + usize::from(route.is_some()); + (rank, marked, taken, origin) } /// Which claims of one Instance at one path may serve it, lower first: the one closest to /// its own path, then the newest epoch. A route's rank chooses only among claims that tie /// here, so an older run never stands in for a newer one that lost its route. -fn precedence(item: &A) -> (u64, Reverse) { +pub(crate) fn precedence(item: &A) -> (u64, Reverse) { (item.above(), Reverse(item.epoch())) } @@ -416,14 +591,13 @@ impl Default for Known { /// The route this node uses, as it stands here: the heard offer with the link added. #[derive(Clone, Debug, PartialEq, Eq)] -struct Best { - via: N, - offer: Offer, +pub(crate) struct Best { + pub via: N, + pub offer: Offer, } -/// How candidate routes order, lower first: rank, then one with no marked link on its -/// path, the next hop in use, the shorter path, the neighbour's Node ID, and its session. -type Order = (bool, Reverse, Metric, bool, bool, usize, NodeId, N); +/// How candidate routes order, lower first, as [`order`] keys them. +pub(crate) type Order = (bool, Reverse, Metric, bool, bool, usize, NodeId, N); /// What a forwarding node's usable routes give the ways to its claims ([`Router::ways`]): /// each one's next hop, rank, and mark, and the next hop of the one in use. @@ -1489,47 +1663,29 @@ impl Router { touched.extend(routes.copied()); } - /// Whether a session on `path` is at or below its pair's floor. - fn floored(&self, path: &[Hop]) -> bool { - pairs(path).any(|(pair, at)| self.closed.get(&pair).is_some_and(|highest| at <= *highest)) - } - - /// Pick the route to `origin`, and mark it stale for the neighbours if it changed. /// Every route to `origin` a neighbour offers that this node may use, as it would /// hold it: priced and ranked over the link it came on. - fn usable(&self, origin: NodeId) -> Vec> { + pub(crate) fn usable(&self, origin: NodeId) -> Vec> { + let here = Here { + closed: &self.closed, + dead: &self.dead, + draining: &self.draining, + }; let mut usable = Vec::new(); for (&via, heard) in self.heard.get(&origin).into_iter().flatten() { self.visit(); let peer = &self.peers[&via]; - let offer = &heard.offer; - if heard.ended - || offer.path.len() >= MAX_HOPS - || self.floored(&offer.path) - || offer.path.iter().any(|hop| self.dead.contains_key(hop)) - { + if heard.ended { continue; } - // A route no link could extend is past every other, so it is never used. - let Some(cost) = offer.cost.checked_add(peer.port.cost) else { - continue; - }; - let draining = - offer.draining || peer.draining || offer.path.iter().any(|hop| self.draining.contains(&hop.node)); - usable.push(Best { - via, - offer: Offer { - path: offer.path.clone(), - draining, - priority: offer.priority.min(peer.port.priority), - cost, - marked: offer.marked || peer.port.upstream, - }, - }); + if let Some(offer) = here.arrive(&peer.port, peer.draining, &heard.offer) { + usable.push(Best { via, offer }); + } } usable } + /// Pick the route to `origin`, and mark it stale for the neighbours if it changed. fn reselect(&mut self, origin: NodeId) { let current = self.best.get(&origin).map(|best| best.via); let mut pick: Option<(Best, Order)> = None; @@ -1541,21 +1697,7 @@ impl Router { best: None, }; for mine in usable { - let via = mine.via; - let offer = mine.offer.clone(); - let (draining, priority, cost) = mine.offer.rank(); - // Among equal ranks one with no marked link, which more neighbours may be sent, - // and then the next hop in use. - let key = ( - draining, - priority, - cost, - mine.offer.marked, - current != Some(via), - offer.path.len(), - offer.path.last().expect("a heard route names its sender").node, - via, - ); + let key = order(&mine, current); if pick.as_ref().is_none_or(|(_, best)| key < *best) { pick = Some((mine, key)); } @@ -1618,49 +1760,14 @@ impl Router { if !self.revs.contains_key(&origin) { return None; } - let me = Hop { - node: self.me, - session: 0, - }; - // The marked identity's route leads through this node, as if learned on a - // marked link, and is never sent over another. - let marked = origin == self.me_marked; - if marked && to.port.upstream { - return None; - } - let path: Arc<[Hop]> = match marked { - true => Arc::new([ - Hop { - node: self.me_marked, - session: 0, - }, - me, - ]), - false => Arc::new([me]), - }; - return Some(Offer { - path, - draining: false, - priority: i8::MAX, - cost: 0, - marked, - }); + return Offer::own(self.me, origin, to.port.upstream); } let best = self.best.get(&origin)?; - // Never back over the session it came on, to a node already on its path, or from - // one marked link to another. - if best.via == peer || names(&best.offer.path, to_id.relay) || (best.offer.marked && to.port.upstream) { + // Never back over the session it came on. + if best.via == peer { return None; } - let mut path = best.offer.path.to_vec(); - path.push(Hop { - node: self.me, - session: self.peers[&best.via].session, - }); - Some(Offer { - path: path.into(), - ..best.offer.clone() - }) + (best.offer).onward(self.me, self.peers[&best.via].session, to_id, to.port.upstream) } /// Tell every routing neighbour of each route that changed, and a neighbour that newly @@ -2011,11 +2118,10 @@ impl Router { if !well_built(&changes) { return Err(Error::Malformed); } - let (cost, priority, upstream) = (peer.port.cost, peer.port.priority, peer.port.upstream); for (broadcast, change) in changes { self.visit(); let change = match change { - Change::Live(claim) if !self.takes(&claim.chain) => { + Change::Live(claim) if !takes(&claim.chain, self.me.relay, self.forwards) => { if let Some(log) = &mut self.log { log.looped += 1; } @@ -2034,15 +2140,9 @@ impl Router { false => continue, } } - Change::Live(mut claim) => { - // Saturating, as `model::origin`'s claim cost does, so a claim's cost - // never decides whether it can serve. - claim.cost = claim.cost.saturating_add(cost); - claim.priority = claim.priority.min(priority); - claim.marked |= upstream; - // The claim enters this node's routing domain here. - self.stamp(&mut claim.chain); - Change::Live(claim) + Change::Live(claim) => { + let port = &self.peers[&from].port; + Change::Live(claim.adopted(self.me.relay, self.forwards, port).expect("taken")) } change => change, }; @@ -2064,26 +2164,6 @@ impl Router { Ok(()) } - /// Whether this node takes a claim whose chain is `chain` from a peer it exchanges no - /// routes with. One naming this node, or any relay twice, left the routing domain of - /// that relay and came back to it, and one this node would carry to the longest path - /// is never taken, as a route past the metric is never used. - fn takes(&self, chain: &[Id]) -> bool { - let me = self.me.relay; - // At most 31 relays (`well_built`), so a quadratic scan beats allocating a set. - let once = (chain.iter().enumerate()).all(|(at, relay)| *relay != me && !chain[..at].contains(relay)); - once && chain.len() + usize::from(self.forwards) < MAX_HOPS - } - - /// Name this node at the end of a claim's chain as the claim enters or leaves its - /// routing domain, unless it ends the chain already, as a relay that adopted a claim - /// across one grant and exports it across the next does. - fn stamp(&self, chain: &mut Vec) { - if self.forwards && chain.last() != Some(&self.me.relay) { - chain.push(self.me.relay); - } - } - fn ungive(&mut self, broadcast: &Broadcast, peer: N) { if let Some(givers) = self.givers.get_mut(broadcast) { givers.remove(&peer); @@ -2105,18 +2185,16 @@ impl Router { claim.draining |= self.peers.get(&peer).is_some_and(|peer| peer.draining); (claim, peer) }) - // Precedence first and then rank, as `closest`, an unavailable claim last. + // Precedence first and then the order `closest` takes, an unavailable claim last. .min_by_key(|(claim, peer)| { + let owner = match claim.marked { + true => self.me_marked, + false => self.me, + }; ( precedence(&claim.item), claim.unavailable, - claim.draining, - Reverse(claim.priority), - claim.cost, - // Among equal ranks one that crossed no marked link, which more - // neighbours may be told, as a route is chosen. - claim.marked, - claim.chain.len(), + claim_order(claim, None, owner), *peer, ) }); @@ -2261,13 +2339,7 @@ impl Router { ways.push(Way { origin, next: Next::Via(route.via), - claim: Claim { - cost: claim.cost.saturating_add(route.offer.cost), - priority: claim.priority.min(route.offer.priority), - draining: claim.draining || route.offer.draining, - marked: claim.marked || route.offer.marked, - ..claim.clone() - }, + claim: claim.over(&route.offer), closest: closest == Some(origin) && best == Some(route.via), }); } @@ -2305,29 +2377,19 @@ impl Router { if claim.unavailable { continue; } - let rank = match self.is_self(origin) { - true => claim.rank(), - false => { - let Some(best) = self.best.get(&origin) else { - continue; - }; - let (draining, Reverse(priority), cost) = best.offer.rank(); - ( - draining || claim.draining, - Reverse(priority.min(claim.priority)), - cost.saturating_add(claim.cost), - ) - } + let route = match self.is_self(origin) { + true => None, + false => match self.best.get(&origin) { + Some(best) => Some(&best.offer), + None => continue, + }, }; - // Counted as the relays that took the claim on its way here: this node's own claim - // names it already, and another's lacks the step from here to its announcer. - let taken = claim.chain.len() + usize::from(!self.is_self(origin)); - let key = (rank, taken, origin); + let key = claim_order(claim, route, origin); if pick.as_ref().is_none_or(|(best, _)| key < *best) { pick = Some((key, claim)); } } - pick.map(|((_, _, origin), claim)| (origin, claim)) + pick.map(|((_, _, _, origin), claim)| (origin, claim)) } // --- Readers, endpoints, and scoped neighbours --- @@ -2536,26 +2598,13 @@ impl Router { fn stands(&self, peer: N, path: &Path, from: &Path, instance: &I) -> Option> { self.reader.get(instance.clone(), from)?; let broadcast = (from.clone(), instance.clone()); - let marked = self.peers[&peer].port.upstream; - let source = |origin: NodeId| { - (self.is_self(origin) && self.sources.get(&broadcast) == Some(&peer)) - || (marked && self.crossed_mark(origin, &broadcast)) - }; + let source = |origin: NodeId| self.is_self(origin) && self.sources.get(&broadcast) == Some(&peer); + // Each claim carries whether it crossed a marked link on its way here, which + // `exported` reads. let claim = match self.closest(&broadcast) { Some((origin, _)) if source(origin) => return None, Some((origin, claim)) if self.is_self(origin) => claim.clone(), - Some((origin, claim)) => { - let route = &self.best[&origin].offer; - Claim { - item: claim.item.clone(), - cost: claim.cost.saturating_add(route.cost), - priority: claim.priority.min(route.priority), - draining: claim.draining || route.draining, - unavailable: false, - chain: claim.chain.clone(), - marked: claim.marked || route.marked, - } - } + Some((origin, claim)) => claim.over(&self.best[&origin].offer), None => match self .claims_of(&broadcast) .min_by_key(|(origin, claim)| (precedence(&claim.item), *origin)) @@ -2569,20 +2618,14 @@ impl Router { // Lost, and waiting out the debounce: what it showed, to every asker alike. None => { let gone = self.gone.get(from)?.get(instance)?; - if gone.source == Some(peer) || (marked && gone.claim.marked) { + if gone.source == Some(peer) { return None; } gone.claim.clone() } }, }; - // The claim leaves this node's routing domain here, so the chain names its exporter, - // and one that would reach the longest path is told to no one. - let mut claim = claim; - self.stamp(&mut claim.chain); - if claim.chain.len() >= MAX_HOPS { - return None; - } + let claim = claim.exported(self.me.relay, self.forwards, self.peers[&peer].port.upstream)?; let by = (path.parts().count() - from.parts().count()) as u64; Some(Told { claim: claim.lowered(by), @@ -2681,6 +2724,11 @@ impl Router { !self.out.is_empty() || !self.stale.is_empty() || !self.fresh.is_empty() } + /// The forwarding nodes some neighbour offers this node a route to. + pub fn heard(&self) -> Vec { + self.heard.keys().copied().collect() + } + /// The forwarding nodes this node routes to. pub fn routes(&self) -> Vec { self.best.keys().copied().collect() @@ -5182,4 +5230,109 @@ mod tests { "a marked neighbour heard of it: {out:?}" ); } + + /// Among claims of equal rank, one no marked link reached is closest, as a route is + /// chosen, so an upstream is told it rather than nothing. Node 4's claim reaches this + /// node over a link it marked and node 5's over one it did not, at the same rank, and + /// node 4 names the lower Node ID. + #[test] + fn an_unmarked_claim_is_closest_among_equal_ranks() { + let mut router: Router = Router::new(node(1), debounce(HOP)); + let upstream = |role| Port { + upstream: true, + ..port(role) + }; + router.connect(2, upstream(Role::Routing(node(2)))).unwrap(); + router.recv(2, Msg::Edited).unwrap(); + open(&mut router, 3, Role::Routing(node(3))); + router.connect(6, upstream(Role::Scoped(vec![p(ROOT)]))).unwrap(); + router.recv(6, Msg::Edited).unwrap(); + let all = Edit { + remove: Vec::new(), + add: vec![p(ROOT)], + }; + router.edit(2, all.clone()).unwrap(); + router.edit(6, all).unwrap(); + router.drain(); + + let room = (p("live"), 7); + for (origin, via) in [(4, 2), (5, 3)] { + router.recv(via, route(origin, via as Id, 1)).unwrap(); + let claims = Msg::Claims { + origin: node(origin), + changes: vec![(room.clone(), claim(run(0), 0))], + floor: 1, + }; + router.recv(via, claims).unwrap(); + } + let out = router.drain(); + let told = (out.iter()).any(|(to, msg)| { + *to == 6 && matches!(msg, Msg::Announce { changes } if changes.iter().any(|(at, change)| *at == room && matches!(change, Change::Live(_)))) + }); + assert!(told, "the upstream was told nothing: {out:?}"); + assert_eq!(router.pick(&room), Some(node(5)), "the unmarked claim is closest"); + } + + /// A route that turns marked at the same rank, through the same session and path, + /// changes which of two equal-rank claims is closest, so it is logged as a change to + /// the ways (#9114 logs only those) and the closest way moves with it. Node 4's claim + /// reaches this node over a link it marked and node 5's over one it did not; then node + /// 5's route turns marked, and node 4's gains an unmarked one. + #[test] + fn a_route_flipping_which_claim_is_unmarked_reaches_its_followers() { + let mut router: Router = Router::new(node(1), debounce(HOP)); + router.follow(); + router + .connect( + 2, + Port { + upstream: true, + ..port(Role::Routing(node(2))) + }, + ) + .unwrap(); + router.recv(2, Msg::Edited).unwrap(); + open(&mut router, 3, Role::Routing(node(3))); + router.drain(); + + let room = (p("live"), 7); + for (origin, via) in [(4, 2), (5, 3)] { + router.recv(via, route(origin, via as Id, 1)).unwrap(); + let claims = Msg::Claims { + origin: node(origin), + changes: vec![(room.clone(), claim(run(0), 0))], + floor: 1, + }; + router.recv(via, claims).unwrap(); + } + router.drain(); + router.changes(); + assert_eq!(router.pick(&room), Some(node(5)), "the unmarked claim is closest"); + + let closest = |router: &Router| { + (router.ways(&room).into_iter()) + .filter(|way| way.closest) + .map(|way| (way.origin, way.next, way.claim.marked)) + .collect::>() + }; + let mut marked = route(5, 3, 1); + if let Msg::Route { offer: Some(offer), .. } = &mut marked { + offer.marked = true; + } + router.recv(3, marked).unwrap(); + router.drain(); + assert_eq!( + router.changes().routes, + BTreeSet::from([node(5)]), + "the mark alone moved" + ); + assert_eq!(router.pick(&room), Some(node(4)), "both marked: the lower Node ID"); + assert_eq!(closest(&router), vec![(node(4), Next::Via(2), true)]); + + router.recv(3, route(4, 3, 1)).unwrap(); + router.drain(); + assert_eq!(router.changes().routes, BTreeSet::from([node(4)]), "an unmarked route"); + assert_eq!(router.pick(&room), Some(node(4)), "the unmarked claim is closest"); + assert_eq!(closest(&router), vec![(node(4), Next::Via(3), false)]); + } } diff --git a/rs/moq-net/src/route/tests/algebra.rs b/rs/moq-net/src/route/tests/algebra.rs index bdf11706ad7..7e8eeaa852f 100644 --- a/rs/moq-net/src/route/tests/algebra.rs +++ b/rs/moq-net/src/route/tests/algebra.rs @@ -1,13 +1,16 @@ -//! Binds the route proof (`rs/moq-net/verify/route-algebra`) to the prototype rule. +//! Binds the route proof (`rs/moq-net/verify/route-algebra`) to [`relay::Router`], the +//! router that ships. //! -//! The proof states the multicast rule as an increasing path algebra and applies -//! Daggitt and Griffin's convergence theorem to it. A route there is what a node -//! would offer: [`Offer::own`], or its best route as [`Offer::onward`] sends it. One -//! step of the algebra is that offer crossing [`Here::arrive`] at a neighbour, and -//! [`order`] picks between the results. Those are the functions the router calls. -//! These tests check them against the algebra's axioms on random links and routes, -//! and write a fixed sample of their results into `Vectors.agda`, each a `refl` -//! that the nightly Agda check must accept, so the two cannot drift apart unseen. +//! The proof states the route rule, and the claims that ride on it, as increasing path +//! algebras and applies Daggitt and Griffin's convergence theorem to them. A route there +//! is what a node would offer: [`Offer::own`], or its route as [`Offer::onward`] sends it. +//! One step of the algebra is that offer taken in by [`Here::arrive`] at a neighbour, and +//! [`order`] picks between the results. A claim steps by [`Claim::over`] within a routing +//! domain, and by [`Claim::exported`] and then [`Claim::adopted`] across a grant, and +//! [`claim_order`] picks. Those are the functions the router calls. These tests check them +//! against the algebras' axioms on random links, routes, and claims, and write a fixed +//! sample of their results into `Vectors.agda` and `ClaimVectors.agda`, each a `refl` that +//! the nightly Agda check must accept, so the two cannot drift apart unseen. use std::{ cmp::Reverse, @@ -16,19 +19,24 @@ use std::{ path::PathBuf, }; -use super::compare::Arm; -use super::multi::{Best, Change, Claim, Here, Hop, Msg, Offer, Port, Role, Router, Tune, floor_of, order, started}; -use super::*; +use crate::route::relay::{ + self, Best, Claim, Here, Hop, NodeId, Offer, Port, Role, claim_order, floor_of, order, precedence, +}; -/// The rule the epic picked: floor, epoch, batch, drain, and claimed. -const KEPT: Tune = Arm::TUNE; +use super::*; /// The node receiving every route here: relay 0 at its first start. -const ME: Id = 1_000; +const ME: NodeId = NodeId { + relay: 0, + start: 1, + marked: false, +}; -/// The checked-in sample, which `ROUTE_VECTORS=write` regenerates. -fn vectors_path() -> PathBuf { - PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("verify/route-algebra/Vectors.agda") +/// The checked-in samples, which `ROUTE_VECTORS=write` regenerates. +fn vectors_path(file: &str) -> PathBuf { + PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("verify/route-algebra") + .join(file) } /// xorshift64, so a seed always draws the same cases. @@ -54,30 +62,85 @@ impl Rng { const PRIORITIES: [i8; 5] = [i8::MIN, -1, 0, 5, i8::MAX]; -/// A node: relays 1 to `relays` at their first or second start, as `hop` names them. -fn node(rng: &mut Rng, relays: u64) -> Id { - 1_000 * (1 + rng.below(2)) + 1 + rng.below(relays) +/// How the proof names a Node ID (`Named.agda`). +fn named(node: NodeId) -> u64 { + 1_000 * (2 * node.start + u64::from(node.marked)) + node.relay +} + +fn marked(node: NodeId) -> NodeId { + NodeId { marked: true, ..node } +} + +/// A node: relays 1 to `relays` at their first or second start. +fn node(rng: &mut Rng, relays: u64) -> NodeId { + NodeId::new(1 + rng.below(relays), 1 + rng.below(2)) +} + +/// How far a priority sits below the highest. +fn penalty(priority: i8) -> i16 { + i16::from(i8::MAX) - i16::from(priority) +} + +fn port(rng: &mut Rng, role: Role) -> Port { + Port { + cost: 1 + rng.below(4), + priority: rng.pick(&PRIORITIES), + upstream: rng.one_in(3), + role, + } } +// --- Routes --- + /// What a neighbour holds for one forwarding node. +#[derive(Clone, Debug)] +enum Holds { + /// Its route to itself. + Own, + /// Its marked identity's route. + Marked, + /// A route it learned, as it holds it. + Learned(Offer), +} + #[derive(Clone, Debug)] struct Held { /// The neighbour. - node: Id, + node: NodeId, /// Its session to its next hop. session: u64, - /// Its best route, or `None` for its route to itself. - best: Option, - /// It announces a claim. + holds: Holds, + /// It announces a claim under its own Node ID. claimed: bool, } impl Held { /// What it sends the receiver over a link it marked `upstream`, as the router does. fn sent(&self, upstream: bool) -> Option { - match &self.best { - None => Offer::own(self.node, KEPT, self.claimed), - Some(best) => best.onward(self.node, self.session, ME, upstream), + match &self.holds { + Holds::Own if !self.claimed => None, + Holds::Own => Offer::own(self.node, self.node, upstream), + Holds::Marked => Offer::own(self.node, marked(self.node), upstream), + Holds::Learned(best) => best.onward(self.node, self.session, ME, upstream), + } + } + + /// Its route as the algebra holds it: before its own send filters, which the link + /// applies. + fn route(&self) -> Offer { + match &self.holds { + Holds::Own => Offer::own(self.node, self.node, false).expect("own route"), + Holds::Marked => Offer::own(self.node, marked(self.node), false).expect("marked route"), + Holds::Learned(best) => { + let path = best.path.iter().copied().chain([Hop { + node: self.node, + session: self.session, + }]); + Offer { + path: path.collect(), + ..best.clone() + } + } } } } @@ -98,67 +161,80 @@ struct Link { #[derive(Clone, Debug, Default)] struct State { closed: BTreeMap<(Id, Id), (u64, u64)>, - dead: BTreeMap, - suspects: BTreeMap>, - draining: BTreeSet, + dead: BTreeMap, + draining: BTreeSet, } impl State { fn here(&self) -> Here<'_> { Here { - me: ME, - tune: KEPT, closed: &self.closed, dead: &self.dead, - suspects: &self.suspects, draining: &self.draining, } } } -fn held(rng: &mut Rng, neighbour: Id) -> Held { - let best = (!rng.one_in(4)).then(|| { - // Now and then long enough to reach the hop limit, without the receiver on - // it so that nothing else refuses it. - let (relays, len, looped) = match rng.one_in(20) { - true => (40, MAX_HOPS as u64 - 3 + rng.below(4), 0), - false => (6, 1 + rng.below(4), 10), - }; - let mut path: Vec = Vec::new(); - while (path.len() as u64) < len { - let id = match looped > 0 && rng.one_in(looped) { - true => ME, - false => node(rng, relays), - }; - if id != neighbour && path.iter().all(|hop| started(hop.node).0 != started(id).0) { - let session = if path.is_empty() { 0 } else { 1 + rng.below(3) }; - path.push(Hop { node: id, session }); - } +/// A path to a node other than `neighbour`, as `neighbour` would hold it: through each +/// relay once, and now and then through the receiver, another start of its relay, or a +/// marked identity first. +fn learned(rng: &mut Rng, neighbour: NodeId) -> Offer { + // Now and then long enough to reach the hop limit, with nothing on it that anything + // else refuses. + let (relays, len, looped) = match rng.one_in(20) { + true => (40, MAX_HOPS as u64 - 3 + rng.below(4), 0), + false => (6, 1 + rng.below(4), 10), + }; + let mut path: Vec = Vec::new(); + if looped > 0 && rng.one_in(5) { + let first = node(rng, relays); + if first.relay != neighbour.relay { + path.push(Hop { + node: marked(first), + session: 0, + }); + path.push(Hop { + node: first, + session: 0, + }); } - Offer { - path, - draining: rng.one_in(4), - priority: rng.pick(&PRIORITIES), - cost: rng.below(12), - marked: rng.one_in(3), + } + while (path.len() as u64) < len { + let id = match looped > 0 && rng.one_in(looped) { + true => NodeId::new(ME.relay, 1 + rng.below(2)), + false => node(rng, relays), + }; + if id.relay != neighbour.relay && path.iter().all(|hop| hop.node.relay != id.relay) { + let session = if path.is_empty() { 0 } else { 1 + rng.below(3) }; + path.push(Hop { node: id, session }); } - }); + } + Offer { + path: path.into(), + draining: rng.one_in(4), + priority: rng.pick(&PRIORITIES), + cost: rng.below(12), + marked: rng.one_in(3), + } +} + +fn held(rng: &mut Rng, neighbour: NodeId) -> Held { + let holds = match rng.below(8) { + 0 | 1 => Holds::Own, + 2 => Holds::Marked, + _ => Holds::Learned(learned(rng, neighbour)), + }; Held { node: neighbour, session: 1 + rng.below(3), - best, + holds, claimed: !rng.one_in(4), } } -fn link(rng: &mut Rng) -> Link { +fn link(rng: &mut Rng, neighbour: NodeId) -> Link { Link { - port: Port { - cost: 1 + rng.below(4), - priority: rng.pick(&PRIORITIES), - upstream: rng.one_in(3), - role: Role::Routing, - }, + port: port(rng, Role::Routing(neighbour)), draining: rng.one_in(4), marked_there: rng.one_in(3), session: 1 + rng.below(3), @@ -168,7 +244,8 @@ fn link(rng: &mut Rng) -> Link { fn state(rng: &mut Rng) -> State { let mut state = State::default(); for _ in 0..rng.below(4) { - let pair = (rng.below(7), rng.below(7)); + // The receiver keeps no floor for its own sessions. + let pair = (1 + rng.below(6), rng.below(7)); state.closed.insert(pair, (1 + rng.below(2), rng.below(4))); } for _ in 0..rng.below(3) { @@ -177,34 +254,31 @@ fn state(rng: &mut Rng) -> State { state } -/// One step of the algebra as the router takes it: the offer as the receiver would -/// send it on, or `None` where it is refused. +/// One step of the algebra as the router takes it: the route the receiver holds, ending +/// at the neighbour, or `None` where it is refused. fn cross(state: &State, link: &Link, held: &Held) -> Option { let sent = held.sent(link.marked_there)?; - let (mut offer, suspect) = state.here().arrive(&link.port, link.draining, &sent)?; - assert!(!suspect, "the picked rule suspects no one"); - offer.path.push(Hop { - node: ME, - session: link.session, - }); - Some(offer) + state.here().arrive(&link.port, link.draining, &sent) } -/// The neighbour's key, as the simulation's routers name their peers. -fn via(node: Id) -> Node { - started(node).0 as Node +/// The route the receiver holds, as the algebra names it: with the receiver's own hop. +fn at_me(offer: Offer, session: u64) -> Offer { + let path = offer.path.iter().copied().chain([Hop { node: ME, session }]); + Offer { + path: path.collect(), + ..offer + } } /// The candidate the router picks, with no next hop in use. -fn pick(candidates: &[(Id, Option)]) -> Option { +fn pick(candidates: &[(NodeId, u64, Option)]) -> Option { (candidates.iter()) - .filter_map(|(node, offer)| { + .filter_map(|(node, session, offer)| { let best = Best { - via: via(*node), + via: named(*node) as Node, offer: offer.clone()?, - suspect: false, }; - Some((order(&best, None), best.offer)) + Some((order(&best, None), at_me(best.offer, *session))) }) .min_by(|(a, _), (b, _)| a.cmp(b)) .map(|(_, offer)| offer) @@ -217,38 +291,34 @@ fn a_step_never_improves_a_route() { for _ in 0..20_000 { let state = state(&mut rng); let neighbour = node(&mut rng, 6); - let (held, link) = (held(&mut rng, neighbour), link(&mut rng)); - let Some(sent) = held.sent(link.marked_there) else { - refused += 1; - continue; - }; + let (held, link) = (held(&mut rng, neighbour), link(&mut rng, neighbour)); let Some(out) = cross(&state, &link, &held) else { refused += 1; continue; }; - // A path naming its receiver is refused, and one taken grows by exactly the - // hop it crossed. - assert!(!sent.path.iter().any(|hop| hop.node == ME), "{sent:?}"); - assert_eq!(out.path[..sent.path.len()], sent.path[..]); - assert_eq!(out.path.len(), sent.path.len() + 1); + let sent = held.route(); + // A path naming the receiver's relay is refused, and one taken grows by exactly + // the receiver's hop. + assert!(!sent.path.iter().any(|hop| hop.node.relay == ME.relay), "{sent:?}"); + assert_eq!(out.path, sent.path); // Drain and priority never improve, and the cost strictly rises. assert!(out.draining >= sent.draining && out.priority <= sent.priority); assert!(out.cost > sent.cost); - assert!((out.draining, Reverse(out.priority), out.cost) > (sent.draining, Reverse(sent.priority), sent.cost)); + assert!(out.rank() > sent.rank()); assert!(out.marked >= sent.marked); } assert!((2_000..18_000).contains(&refused), "{refused} of 20000 refused"); } -/// With `floor`, the dead hops a node keeps refuse nothing the floor does not, since -/// `closed` files every one of them in the floor too. +/// The dead hops a node keeps refuse nothing the floor does not, since `closed` files +/// every one of them in the floor too. #[test] fn the_floor_refuses_every_dead_hop() { let mut rng = Rng(0x2545_f491_4f6c_dd1d); for _ in 0..20_000 { let mut state = state(&mut rng); let neighbour = node(&mut rng, 6); - let (held, link) = (held(&mut rng, neighbour), link(&mut rng)); + let (held, link) = (held(&mut rng, neighbour), link(&mut rng, neighbour)); let Some(sent) = held.sent(link.marked_there) else { continue; }; @@ -258,7 +328,7 @@ fn the_floor_refuses_every_dead_hop() { for pair in sent.path.windows(2).filter(|_| rng.one_in(2)) { let (hop, far) = (pair[1], pair[0].node); floored.dead.insert(hop, far); - let (key, at) = floor_of(KEPT, hop, far); + let (key, at) = floor_of(hop, far); let highest = floored.closed.entry(key).or_default(); *highest = (*highest).max(at); } @@ -274,20 +344,19 @@ fn candidates_order_totally() { for _ in 0..20_000 { let state = state(&mut rng); let (a, b) = (node(&mut rng, 6), node(&mut rng, 6)); - if via(a) == via(b) { + if a == b { continue; } - let one = cross(&state, &link(&mut rng), &held(&mut rng, a)); - let two = cross(&state, &link(&mut rng), &held(&mut rng, b)); + let one = cross(&state, &link(&mut rng, a), &held(&mut rng, a)); + let two = cross(&state, &link(&mut rng, b), &held(&mut rng, b)); let (Some(one), Some(two)) = (one, two) else { continue; }; - let key = |node: Id, offer: &Offer| { + let key = |node: NodeId, offer: &Offer| { order( &Best { - via: via(node), + via: named(node) as Node, offer: offer.clone(), - suspect: false, }, None, ) @@ -296,69 +365,8 @@ fn candidates_order_totally() { } } -/// Claims across a scoped grant take the same kind of step: the receiving node adds -/// the link's cost, takes the lower priority, keeps a drain, appends itself to the -/// chain, and refuses a claim whose chain names it. -#[test] -fn a_grant_never_improves_a_claim() { - let mut rng = Rng(0xd1b5_4a32_d192_ed03); - for _ in 0..2_000 { - let mut router: Router = Router::new(ME, KEPT); - let (from, to) = (1, 2); - let port = Port { - cost: 1 + rng.below(4), - priority: rng.pick(&PRIORITIES), - upstream: false, - role: Role::Scoped, - }; - router.connect(from, hop(from, 0), port); - router.connect(to, hop(to, 0), Port { cost: 1, ..port }); - router.drain(); - let mut chain: Vec = (0..rng.below(3)).map(|_| node(&mut rng, 6)).collect(); - if rng.one_in(4) { - chain.insert(rng.below(chain.len() as u64 + 1) as usize, ME); - } - let claim = Claim { - cost: rng.below(12), - priority: rng.pick(&PRIORITIES), - draining: rng.one_in(4), - chain, - }; - let broadcast: multi::Broadcast = (7, p("live")); - router.recv( - from, - Msg::Foreign { - changes: vec![(broadcast.clone(), Change::Live(claim.clone()))], - }, - ); - let sent: Vec = (router.drain().into_iter()) - .filter(|(peer, _)| *peer == to) - .flat_map(|(_, msg)| match msg { - Msg::Foreign { changes } => changes, - other => panic!("{other:?} to a scoped neighbour"), - }) - .filter_map(|(_, change)| match change { - Change::Live(claim) => Some(claim), - _ => None, - }) - .collect(); - if claim.chain.contains(&ME) { - assert!(sent.is_empty(), "{sent:?}"); - continue; - } - let [out] = &sent[..] else { - panic!("{sent:?}"); - }; - assert!(out.cost >= claim.cost + port.cost); - assert_eq!(out.priority, claim.priority.min(port.priority)); - assert_eq!(out.draining, claim.draining); - assert_eq!(out.chain[..claim.chain.len()], claim.chain[..]); - assert_eq!(out.chain[claim.chain.len()..], [ME]); - } -} - -/// The Agda term for `offer` as a node sends it: its path from that node to the one -/// it leads to, each link with the session its nearer end holds it on. +/// The Agda term for `offer` as a node holds it, its own hop last: its path from that +/// node to the one it leads to, each link with the session its nearer end holds it on. fn weight(offer: Option<&Offer>) -> String { let Some(offer) = offer else { return "invalid".into(); @@ -367,11 +375,11 @@ fn weight(offer: Option<&Offer>) -> String { let mut path = String::new(); let mut sessions = String::new(); for pair in hops.windows(2).rev() { - write!(path, "({} , {}) ∷ ", pair[1].node, pair[0].node).unwrap(); + write!(path, "({} , {}) ∷ ", named(pair[1].node), named(pair[0].node)).unwrap(); write!(sessions, "{} ∷ ", pair[1].session).unwrap(); } format!( - "valid (route {} {} {} {} ({path}[]) ({sessions}[]))", + "valid (route tt {} {} {} {} ({path}[]) ({sessions}[]))", offer.draining, penalty(offer.priority), offer.cost, @@ -379,72 +387,81 @@ fn weight(offer: Option<&Offer>) -> String { ) } -/// How far a priority sits below the highest. -fn penalty(priority: i8) -> i16 { - i16::from(i8::MAX) - i16::from(priority) -} - -fn agda_link(state: &State, link: &Link, held: &Held) -> String { +/// The Agda term for the link from the receiver to a neighbour. +fn agda_link(state: &State, port: &Port, draining: bool, marked_there: bool, claimed: bool, session: u64) -> String { let mut floors = String::new(); for ((near, far), (start, session)) in &state.closed { write!(floors, "floor {near} {far} {start} {session} ∷ ").unwrap(); } - let mut draining = String::new(); + let mut named_draining = String::new(); for node in &state.draining { - write!(draining, "{node} ∷ ").unwrap(); + write!(named_draining, "{} ∷ ", named(*node)).unwrap(); } format!( - "link true {} {} {} ({draining}[]) ({floors}[]) {} {} {} {}", - link.port.cost, - penalty(link.port.priority), - link.draining, - link.port.upstream, - link.marked_there, - held.claimed, - link.session, + "link true {} {} {draining} ({named_draining}[]) ({floors}[]) {} {marked_there} {claimed} {session}", + port.cost, + penalty(port.priority), + port.upstream, ) } fn agda_step(state: &State, link: &Link, held: &Held) -> String { - // The neighbour's route as the algebra holds it: before its own mark filter, - // which the link applies. - let route = match &held.best { - None => Some(Offer::own(held.node, KEPT, true).expect("own route")), - Some(best) => { - let mut offer = best.clone(); - offer.path.push(Hop { - node: held.node, - session: held.session, - }); - Some(offer) - } - }; format!( - "extend ({}) ({ME} , {}) ({})", - agda_link(state, link, held), - held.node, - weight(route.as_ref()) + "extend ({}) ({} , {}) ({})", + agda_link( + state, + &link.port, + link.draining, + link.marked_there, + held.claimed, + link.session + ), + named(ME), + named(held.node), + weight(Some(&held.route())) ) } -/// The sample: single steps, then picks between two neighbours' offers. -fn vectors() -> String { +/// The route sample: the receiver's marked route, single steps, then picks between two +/// neighbours' offers. +fn route_vectors() -> String { let mut out = String::from( "-- Generated by `rs/moq-net/src/route/tests/algebra.rs` (`ROUTE_VECTORS=write`); do not edit.\n\ - -- Each case is a result the Rust prototype computed, which the algebra must compute too.\n\n\ + -- Each case is a result `route::relay::Router` computed, which the algebra must compute too.\n\n\ module Vectors where\n\n\ open import Data.Bool.Base using (true; false)\n\ open import Data.List.Base using ([]; _∷_)\n\ open import Data.Product.Base using (_,_)\n\ + open import Data.Unit.Base using (tt)\n\ open import Relation.Binary.PropositionalEquality using (_≡_; refl)\n\n\ - open import Sim\n", + open import Named\n", ); let mut rng = Rng(0x0123_4567_89ab_cdef); + // The receiver's marked identity hangs off it by a free, marked link at session 0. + for claimed in [true, false] { + let state = state(&mut rng); + let free = Port { + cost: 0, + priority: i8::MAX, + upstream: true, + role: Role::Endpoint, + }; + let own = claimed.then(|| Offer::own(ME, marked(ME), false)).flatten(); + write!( + out, + "\n_ : extend ({}) ({} , {}) (valid (route tt false 0 0 false [] []))\n ≡ {}\n_ = refl\n", + agda_link(&state, &free, false, false, claimed, 0), + named(ME), + named(marked(ME)), + weight(own.as_ref()) + ) + .unwrap(); + } for _ in 0..200 { let state = state(&mut rng); let neighbour = node(&mut rng, 6); - let (held, link) = (held(&mut rng, neighbour), link(&mut rng)); - let result = cross(&state, &link, &held); + let (held, link) = (held(&mut rng, neighbour), link(&mut rng, neighbour)); + let result = cross(&state, &link, &held).map(|offer| at_me(offer, link.session)); write!( out, "\n_ : {}\n ≡ {}\n_ = refl\n", @@ -456,23 +473,42 @@ fn vectors() -> String { for _ in 0..150 { let state = state(&mut rng); let (a, b) = (node(&mut rng, 6), node(&mut rng, 6)); - if via(a) == via(b) { + if a == b { continue; } - let one = (held(&mut rng, a), link(&mut rng)); - // Half the pairs offer the same route over the same kind of link, so only the - // neighbour breaks the tie. - let two = match rng.one_in(2) { - true => ( - Held { - node: b, - ..one.0.clone() - }, - one.1.clone(), - ), - false => (held(&mut rng, b), link(&mut rng)), + let one = (held(&mut rng, a), link(&mut rng, a)); + // A third of the pairs offer the same route over the same kind of link, so only the + // neighbour breaks the tie, and a third the same with the other mark or one more + // hop, so that decides. + let two = match rng.below(3) { + 0 => (held(&mut rng, b), link(&mut rng, b)), + tweak => { + let mut two = ( + Held { + node: b, + ..one.0.clone() + }, + one.1.clone(), + ); + if tweak == 2 { + match &mut two.0.holds { + Holds::Learned(best) if rng.one_in(2) && best.path.len() < MAX_HOPS - 3 => { + let hop = Hop { + node: NodeId::new(100 + rng.below(100), 1), + session: 1, + }; + best.path = best.path.iter().copied().chain([hop]).collect(); + } + _ => two.1.port.upstream = !two.1.port.upstream, + } + } + two + } }; - let picked = pick(&[(a, cross(&state, &one.1, &one.0)), (b, cross(&state, &two.1, &two.0))]); + let picked = pick(&[ + (a, one.1.session, cross(&state, &one.1, &one.0)), + (b, two.1.session, cross(&state, &two.1, &two.0)), + ]); write!( out, "\n_ : {}\n ⊕ {}\n ≡ {}\n_ = refl\n", @@ -485,18 +521,592 @@ fn vectors() -> String { out } +// --- Claims --- + +/// What the proof names the publisher and the broadcast it publishes (`Claim.agda`). +const PUBLISHER: Id = 1; +const BROADCAST: Id = 0; + +/// Attributes with an epoch and a distance, as a restarted publisher's claims, or a +/// broader claim presented at a narrower path, carry. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +struct Run { + epoch: u64, + above: u64, +} + +impl Item for Run { + fn lowered(&self, by: u64) -> Self { + Self { + above: self.above + by, + ..*self + } + } + + fn above(&self) -> u64 { + self.above + } + + fn epoch(&self) -> u64 { + self.epoch + } +} + +/// How a node holds a claim. +#[derive(Clone, Debug)] +enum Kind { + /// The publisher's own. + Published, + /// The node's own, taken from a giver it keys so. + Own { giver: u64 }, + /// Another node's of its routing domain, over its route there. + Over { origin: NodeId }, +} + +/// A claim as a node holds it. +#[derive(Clone, Debug)] +struct Holding { + holder: NodeId, + /// As it stands at the holder. + claim: Claim, + kind: Kind, +} + +impl Holding { + /// The relays that handed it on, from the holder to the publisher and its broadcast: + /// the holder, unless the chain ends with it, then the chain backward. + fn nodes(&self) -> Vec { + let mut nodes = match self.kind { + Kind::Published => Vec::new(), + Kind::Own { .. } => Vec::new(), + Kind::Over { .. } => vec![self.holder.relay], + }; + nodes.extend(self.claim.chain.iter().rev()); + nodes.extend([PUBLISHER, BROADCAST]); + nodes + } + + /// Its claimant, and the holder's key for its giver. + fn extra(&self) -> (NodeId, u64) { + match self.kind { + Kind::Published => (NodeId::new(0, 0), 0), + Kind::Own { giver } => ( + NodeId { + marked: self.claim.marked, + ..self.holder + }, + giver, + ), + Kind::Over { origin } => (origin, 0), + } + } +} + +fn run(rng: &mut Rng) -> Run { + Run { + epoch: rng.below(3), + above: rng.below(2), + } +} + +/// A chain of distinct relays 2 and up, now and then long enough to reach the longest. +fn chain(rng: &mut Rng, len: usize) -> Vec { + let relays = if len > 8 { 60 } else { 8 }; + let mut chain = Vec::new(); + while chain.len() < len { + let relay = 2 + rng.below(relays); + if !chain.contains(&relay) { + chain.push(relay); + } + } + chain +} + +fn chain_len(rng: &mut Rng) -> usize { + match rng.one_in(15) { + true => MAX_HOPS - 4 + rng.below(4) as usize, + false => 1 + rng.below(3) as usize, + } +} + +fn claim(rng: &mut Rng, chain: Vec) -> Claim { + Claim { + item: run(rng), + cost: rng.below(12), + priority: rng.pick(&PRIORITIES), + draining: rng.one_in(4), + unavailable: false, + chain, + marked: rng.one_in(3), + } +} + +/// A relay's own claim, its chain ending with it. +fn own(rng: &mut Rng, holder: NodeId) -> Holding { + let len = chain_len(rng) - 1; + let mut chain = chain(rng, len); + chain.retain(|relay| *relay != holder.relay); + chain.push(holder.relay); + Holding { + holder, + claim: claim(rng, chain), + kind: Kind::Own { + giver: 1 + rng.below(9), + }, + } +} + +/// What the publisher announces. +fn published(rng: &mut Rng) -> Holding { + Holding { + holder: NodeId::new(PUBLISHER, 0), + claim: Claim { + item: Run { + epoch: rng.below(3), + above: 0, + }, + cost: 0, + priority: i8::MAX, + draining: false, + unavailable: false, + chain: Vec::new(), + marked: false, + }, + kind: Kind::Published, + } +} + +/// A relay of up to `relays`, at its first or second start. +fn relay(rng: &mut Rng, relays: u64) -> NodeId { + NodeId::new(2 + rng.below(relays), 1 + rng.below(2)) +} + +/// A route a node holds to another of its routing domain: its rank and mark are all a +/// claim reads of it. +fn domain_route(rng: &mut Rng, to: NodeId) -> Offer { + Offer { + path: [Hop { node: to, session: 0 }].into(), + draining: rng.one_in(4), + priority: rng.pick(&PRIORITIES), + cost: 1 + rng.below(12), + marked: rng.one_in(3), + } +} + +/// A precedence near `at`: itself mostly, now and then a better or a worse one. +fn top(rng: &mut Rng, at: (u64, Reverse)) -> (u64, Reverse) { + let (above, Reverse(epoch)) = at; + match rng.below(6) { + 0 if above > 0 => (above - 1, Reverse(epoch)), + 0 => (above, Reverse(epoch + 1)), + 1 => (above + 1, Reverse(epoch)), + _ => at, + } +} + +/// One step a claim takes into node `to`, with what the receiver knows: the best +/// precedence of any claim it knows of the broadcast, reachable or not. +#[derive(Clone, Debug)] +enum Step { + /// `from` tells `to` the claim across a grant, or as its endpoint. + Adopt { + from: Holding, + /// The giver marked the link. + marked_there: bool, + /// How far below the claim's path `to` is shown it. + by: u64, + /// `to`'s port to the giver. + port: Port, + /// The giver sent GOAWAY. + draining: bool, + /// `to`'s key for the giver. + giver: u64, + }, + /// `to` takes the claim of `from`, an announcer of its routing domain, over its route + /// there. + Over { from: Holding, route: Offer }, +} + +#[derive(Clone, Debug)] +struct Taken { + to: NodeId, + step: Step, + top: (u64, Reverse), +} + +impl Taken { + fn from(&self) -> &Holding { + match &self.step { + Step::Adopt { from, .. } | Step::Over { from, .. } => from, + } + } + + /// The claim as the router takes it, before the receiver's precedence filter. + fn unfiltered(&self) -> Option { + match &self.step { + Step::Adopt { + from, + marked_there, + by, + port, + draining, + giver, + } => { + // An endpoint tells its own claim as it is; a relay exports it. + let told = match from.kind { + Kind::Published => from.claim.clone(), + _ => from + .claim + .exported(from.holder.relay, true, *marked_there)? + .lowered(*by), + }; + let mut claim = told.adopted(self.to.relay, true, port)?; + // As `restate` takes it from a giver that sent GOAWAY. + claim.draining |= draining; + Some(Holding { + holder: self.to, + claim, + kind: Kind::Own { giver: *giver }, + }) + } + Step::Over { from, route } => { + let (origin, _) = from.extra(); + Some(Holding { + holder: self.to, + claim: from.claim.over(route), + kind: Kind::Over { origin }, + }) + } + } + } + + /// The claim as the router takes it, or `None` where it is refused: as `closest` + /// passes over one below the best precedence it knows. + fn taken(&self) -> Option { + self.unfiltered() + .filter(|held| precedence(&held.claim.item) <= self.top) + } + + /// How the router orders it among the candidates at `to`, as `restate` and then + /// `closest` do. + fn key(&self) -> Option<((u64, Reverse), relay::ClaimOrder, u64)> { + let held = self.taken()?; + let order = match &self.step { + Step::Adopt { giver, .. } => { + let (owner, _) = held.extra(); + (claim_order(&held.claim, None, owner), *giver) + } + Step::Over { from, route } => { + let (origin, _) = from.extra(); + (claim_order(&from.claim, Some(route), origin), 0) + } + }; + Some((precedence(&held.claim.item), order.0, order.1)) + } +} + +/// A step into `to`: across a grant from a relay holding a claim of its own or of its +/// domain, from the publisher, or within `to`'s domain. +fn taken(rng: &mut Rng, to: NodeId) -> Taken { + let step = match rng.below(5) { + 0 => Step::Adopt { + from: published(rng), + marked_there: false, + by: 0, + port: port(rng, Role::Endpoint), + draining: rng.one_in(4), + giver: 1 + rng.below(9), + }, + 1 | 2 => { + let giver = relay(rng, 8); + let mut from = match rng.one_in(2) { + true => own(rng, giver), + false => { + let origin = relay(rng, 8); + if origin.relay == giver.relay || origin.relay == to.relay { + return taken(rng, to); + } + let mut announced = own(rng, origin); + // One that left the giver's domain and came back is the case the proof + // leaves out. + announced.claim.chain.retain(|relay| *relay != giver.relay); + let route = domain_route(rng, origin); + Holding { + holder: giver, + claim: announced.claim.over(&route), + kind: Kind::Over { + origin: announced.extra().0, + }, + } + } + }; + // Now and then the receiver is on the chain already. + if !rng.one_in(6) { + from.claim.chain.retain(|relay| *relay != to.relay); + } + if from.claim.chain.is_empty() || from.holder.relay == to.relay { + return taken(rng, to); + } + Step::Adopt { + from, + marked_there: rng.one_in(3), + by: rng.below(2), + port: port(rng, Role::Scoped(Vec::new())), + draining: rng.one_in(4), + giver: 1 + rng.below(9), + } + } + _ => { + let origin = relay(rng, 8); + if origin.relay == to.relay { + return taken(rng, to); + } + let mut from = own(rng, origin); + // The receiver on the chain is the case the proof leaves out: no node within a + // domain checks the chain. + from.claim.chain.retain(|relay| *relay != to.relay); + if from.claim.chain.is_empty() { + return taken(rng, to); + } + let route = domain_route(rng, origin); + Step::Over { from, route } + } + }; + let mut taken = Taken { + to, + step, + top: (0, Reverse(0)), + }; + taken.top = match taken.unfiltered() { + Some(held) => top(rng, precedence(&held.claim.item)), + None => (rng.below(2), Reverse(rng.below(3))), + }; + taken +} + +fn holds_well(held: &Holding) { + if let Kind::Own { .. } = held.kind { + assert_eq!(held.claim.chain.last(), Some(&held.holder.relay), "{held:?}"); + } +} + +/// Across a grant, from an endpoint, and within a domain, a claim never improves: its +/// precedence, rank, and mark never get better, and its path grows by exactly the hop it +/// crossed, so Rust's chain maps onto the algebra's path. #[test] -fn the_agda_sample_is_current() { - let path = vectors_path(); - let now = vectors(); - if std::env::var("ROUTE_VECTORS").as_deref() == Ok("write") { - std::fs::write(&path, &now).unwrap(); - return; - } - let checked_in = std::fs::read_to_string(&path).unwrap(); - assert!( - checked_in == now, - "{} is stale: rerun this test with ROUTE_VECTORS=write, then `just test route-proof`", - path.display() +fn a_claim_step_never_improves_a_claim() { + let mut rng = Rng(0xd1b5_4a32_d192_ed03); + let (mut refused, mut over) = (0, 0); + for _ in 0..20_000 { + let to = relay(&mut rng, 8); + let step = taken(&mut rng, to); + let from = step.from(); + holds_well(from); + let Some(out) = step.unfiltered() else { + refused += 1; + continue; + }; + holds_well(&out); + over += usize::from(matches!(step.step, Step::Over { .. })); + let (a, b) = (&from.claim, &out.claim); + assert!(precedence(&b.item) >= precedence(&a.item)); + assert!(b.draining >= a.draining && b.priority <= a.priority && b.cost >= a.cost); + assert!(b.marked >= a.marked); + let (before, after) = (from.nodes(), out.nodes()); + assert_eq!(after[1..], before[..], "{from:?} to {out:?}"); + assert_eq!(after[0], to.relay); + assert!(!before.contains(&to.relay), "{from:?} to {out:?}"); + } + assert!((1_000..10_000).contains(&refused), "{refused} of 20000 refused"); + assert!(over > 5_000, "{over} domain steps"); +} + +/// The Agda term for a claim as its holder holds it. +fn claim_weight(held: Option<&Holding>) -> String { + let Some(held) = held else { + return "invalid".into(); + }; + let nodes = held.nodes(); + let mut path = String::new(); + for pair in nodes.windows(2) { + write!(path, "({} , {}) ∷ ", pair[0], pair[1]).unwrap(); + } + let (claimant, giver) = held.extra(); + let claim = &held.claim; + format!( + "valid (route ({} , just {}) {} {} {} {} ({path}[]) (({} , {} , {}) , {giver}))", + claim.item.above, + claim.item.epoch, + claim.draining, + penalty(claim.priority), + claim.cost, + claim.marked, + claimant.relay, + claimant.start, + u64::from(claimant.marked), + ) +} + +fn claim_step(taken: &Taken) -> String { + let (above, Reverse(epoch)) = taken.top; + let (to, from) = (taken.to, taken.from()); + let link = match &taken.step { + Step::Adopt { + marked_there, + by, + port, + draining, + giver, + .. + } => format!( + "step true {} {} {draining} {} {marked_there} true {by} nothing ({above} , just {epoch}) ({} , {}) {giver}", + port.cost, + penalty(port.priority), + port.upstream, + to.relay, + to.start, + ), + Step::Over { route, .. } => format!( + "step true {} {} {} {} false false 0 nothing ({above} , just {epoch}) ({} , {}) 0", + route.cost, + penalty(route.priority), + route.draining, + route.marked, + to.relay, + to.start, + ), + }; + let edge = (to.relay, from.nodes()[0]); + format!( + "extend ({link}) ({} , {}) ({})", + edge.0, + edge.1, + claim_weight(Some(from)) + ) +} + +/// The same claim as `from` holds it, held by `other` instead, which neither `to` nor +/// any relay on its chain is. False where it cannot be. +fn moved(from: &mut Holding, to: NodeId, other: NodeId) -> bool { + let chain = &mut from.claim.chain; + let named = match from.kind { + Kind::Published => return false, + Kind::Own { .. } => chain[..chain.len() - 1].contains(&other.relay), + Kind::Over { .. } => chain.contains(&other.relay), + }; + if named || other.relay == to.relay || other.relay == from.holder.relay { + return false; + } + if let Kind::Own { .. } = from.kind { + *chain.last_mut().expect("its own") = other.relay; + } + from.holder = other; + true +} + +/// The claim sample: single steps, then picks between two candidates at one node. +fn claim_vectors() -> String { + let mut out = String::from( + "-- Generated by `rs/moq-net/src/route/tests/algebra.rs` (`ROUTE_VECTORS=write`); do not edit.\n\ + -- Each case is a result `route::relay::Router` computed of a claim, which the algebra must compute too.\n\n\ + module ClaimVectors where\n\n\ + open import Data.Bool.Base using (true; false)\n\ + open import Data.List.Base using ([]; _∷_)\n\ + open import Data.Maybe.Base using (nothing; just)\n\ + open import Data.Product.Base using (_,_)\n\ + open import Relation.Binary.PropositionalEquality using (_≡_; refl)\n\n\ + open import Claim\n", ); + let mut rng = Rng(0x0f1e_2d3c_4b5a_6978); + for _ in 0..200 { + let to = relay(&mut rng, 8); + let step = taken(&mut rng, to); + write!( + out, + "\n_ : {}\n ≡ {}\n_ = refl\n", + claim_step(&step), + claim_weight(step.taken().as_ref()) + ) + .unwrap(); + } + let mut picks = 0; + while picks < 120 { + let to = relay(&mut rng, 8); + let one = taken(&mut rng, to); + // A third of the pairs take the same claim the same way from another giver or + // announcer, so only the claimant or the giver breaks the tie, and a third the same + // with the other mark or one more relay on the chain, so that decides. + let mut two = match rng.below(3) { + 0 => taken(&mut rng, to), + tweak => { + let mut two = one.clone(); + let other = relay(&mut rng, 8); + let (Step::Adopt { from, .. } | Step::Over { from, .. }) = &mut two.step; + if !moved(from, to, other) { + continue; + } + if tweak == 2 && rng.one_in(2) { + // A relay outside every chain here, which no step refuses. + from.claim.chain.insert(0, 100 + rng.below(100)); + } else if tweak == 2 { + match &mut two.step { + Step::Adopt { port, .. } => port.upstream = !port.upstream, + Step::Over { route, .. } => route.marked = !route.marked, + } + } + if let Step::Adopt { giver, .. } = &mut two.step { + *giver = 1 + (*giver % 9); + } + two + } + }; + two.top = one.top; + // One holder takes a claim from a giver once, and one claimant has one claim. + let distinct = match (&one.step, &two.step) { + (Step::Adopt { giver: a, from: x, .. }, Step::Adopt { giver: b, from: y, .. }) => { + a != b && x.holder.relay != y.holder.relay + } + (Step::Over { from: x, .. }, Step::Over { from: y, .. }) => x.extra().0 != y.extra().0, + _ => true, + }; + if !distinct { + continue; + } + picks += 1; + let picked = [&one, &two] + .into_iter() + .filter_map(|step| Some((step.key()?, step.taken()?))) + .min_by(|(a, _), (b, _)| a.cmp(b)) + .map(|(_, held)| held); + write!( + out, + "\n_ : {}\n ⊕ {}\n ≡ {}\n_ = refl\n", + claim_step(&one), + claim_step(&two), + claim_weight(picked.as_ref()) + ) + .unwrap(); + } + out +} + +#[test] +fn the_agda_samples_are_current() { + let write = std::env::var("ROUTE_VECTORS").as_deref() == Ok("write"); + for (file, now) in [ + ("Vectors.agda", route_vectors()), + ("ClaimVectors.agda", claim_vectors()), + ] { + let path = vectors_path(file); + if write { + std::fs::write(&path, &now).unwrap(); + continue; + } + let checked_in = std::fs::read_to_string(&path).unwrap(); + assert!( + checked_in == now, + "{} is stale: rerun this test with ROUTE_VECTORS=write, then `just test route-proof`", + path.display() + ); + } } diff --git a/rs/moq-net/src/route/tests/multi.rs b/rs/moq-net/src/route/tests/multi.rs index 53f0122e278..5e29157317e 100644 --- a/rs/moq-net/src/route/tests/multi.rs +++ b/rs/moq-net/src/route/tests/multi.rs @@ -999,16 +999,6 @@ impl Router { out } - /// Whether it offers a route to itself under `tune.claimed`: it has announced a claim. - pub fn announced(&self) -> bool { - self.announced - } - - /// The route this node uses to `origin`. - pub fn best(&self, origin: Id) -> Option<&Best> { - self.best.get(&origin) - } - /// Every forwarding node this node has heard a route to or uses one to. pub fn origins(&self) -> BTreeSet { self.heard.keys().chain(self.best.keys()).copied().collect() @@ -1553,15 +1543,6 @@ impl MultiSim { self.held.insert((from, to)); } - pub fn release(&mut self, from: Node, to: Node) { - self.held.remove(&(from, to)); - } - - /// Whether `a` and `b` have a session open. - pub fn is_up(&self, a: Node, b: Node) -> bool { - self.up.contains(&Self::pair(a, b)) - } - pub fn ready(&self) -> Vec<((Node, Node), usize)> { (self.queues.iter()) .filter(|(key, queue)| !queue.is_empty() && !self.held.contains(key)) diff --git a/rs/moq-net/src/route/tests/sticky.rs b/rs/moq-net/src/route/tests/sticky.rs index ceed82dec76..1ad4b0025d2 100644 --- a/rs/moq-net/src/route/tests/sticky.rs +++ b/rs/moq-net/src/route/tests/sticky.rs @@ -1,27 +1,26 @@ -//! The route rule as the prototype runs it, with the next hop in use ahead of the -//! path length and the neighbour in [`order`](super::multi::order). +//! The route rule as [`relay::Router`] runs it, with the next hop in use ahead of the +//! path length and the neighbour in [`relay::order`]. //! -//! The route proof (`rs/moq-net/verify/route-algebra`) breaks ties between routes -//! of equal draining, priority, cost, and mark by a fixed order, so it has one -//! fixed point. Staying on the next hop in use makes the choice depend on what -//! came first, which the proof does not cover. `rs/moq-net/verify/route-algebra/README.md` -//! argues on paper that the rule still settles, at every node on the rank and mark -//! the fixed order would give it; these tests check both. +//! The route proof (`rs/moq-net/verify/route-algebra`) breaks ties between routes of +//! equal draining, priority, cost, and mark by a fixed order, so it has one fixed point. +//! Staying on the next hop in use makes the choice depend on what came first, which the +//! proof does not cover. `rs/moq-net/verify/route-algebra/README.md` argues on paper that +//! the rule still settles, at every node on the rank and mark the fixed order would give +//! it; these tests check both. + +use crate::route::relay::{self, Best, NodeId}; use super::algebra::Rng; -use super::compare::Arm; -use super::multi::{Best, MultiSim, Tie, Tune}; +use super::multi::Tie; +use super::multicast::{RelaySim, Router}; use super::*; -/// The rule the epic picked: floor, epoch, batch, drain, and claimed. -const KEPT: Tune = Arm::TUNE; - /// More deliveries than any network here needs to settle. const LIMIT: usize = 200_000; -/// A random network: relays first, then publishers, each relay linked to an -/// earlier one and a few more links besides, costs of 1 or 2 so equal ranks are -/// common, and one link in four marked upstream. +/// A random network: relays first, then publishers, each relay linked to an earlier one +/// and a few more links besides, costs of 1 or 2 so equal ranks are common, and one link +/// in four marked upstream. struct Net { relays: usize, publishers: usize, @@ -67,8 +66,8 @@ impl Net { } } - fn build(&self) -> MultiSim { - let mut net = MultiSim::new(KEPT, self.relays + self.publishers); + fn build(&self) -> RelaySim { + let mut net = RelaySim::new(self.relays + self.publishers, relay::debounce(HOP)); for publisher in self.relays..self.relays + self.publishers { net.client(publisher); net.publish(publisher, 100 + publisher as Id); @@ -83,9 +82,13 @@ impl Net { } } -/// Deliver one message at a time from a random queue, reading a burst before -/// answering as `batch` does, until nothing is left. False if it never settles. -fn settle(net: &mut MultiSim, rng: &mut Rng) -> bool { +fn is_up(net: &RelaySim, a: Node, b: Node) -> bool { + net.up().contains(&(a.min(b), a.max(b))) +} + +/// Deliver one message at a time from a random queue, reading a burst before answering, +/// until nothing is left. False if it never settles. +fn settle(net: &mut RelaySim, rng: &mut Rng) -> bool { for _ in 0..LIMIT { let ready = net.ready(); if ready.is_empty() { @@ -104,9 +107,9 @@ fn settle(net: &mut MultiSim, rng: &mut Rng) -> bool { false } -/// Links close and reopen, relays restart or send GOAWAY, all while messages are -/// in flight; then every closed link reopens. -fn churn(net: &mut MultiSim, plan: &Net, rng: &mut Rng) { +/// Links close and reopen, relays restart or send GOAWAY, all while messages are in +/// flight; then every closed link reopens. +fn churn(net: &mut RelaySim, plan: &Net, rng: &mut Rng) { let mut down = Vec::new(); for _ in 0..rng.below(6) { for _ in 0..rng.below(40) { @@ -122,7 +125,7 @@ fn churn(net: &mut MultiSim, plan: &Net, rng: &mut Rng) { match rng.below(5) { 0 => { let links: Vec<_> = (plan.links.iter()) - .filter(|&&(a, b, _, _)| (a == relay || b == relay) && net.is_up(a, b)) + .filter(|&&(a, b, _, _)| (a == relay || b == relay) && is_up(net, a, b)) .map(|&(a, b, _, _)| (a, b)) .collect(); net.reset(relay); @@ -131,7 +134,7 @@ fn churn(net: &mut MultiSim, plan: &Net, rng: &mut Rng) { 1 => net.goaway(relay), _ => { let &(a, b, _, _) = &plan.links[rng.below(plan.links.len() as u64) as usize]; - if net.is_up(a, b) { + if is_up(net, a, b) { net.close(a, b); down.push((a, b)); } @@ -139,54 +142,69 @@ fn churn(net: &mut MultiSim, plan: &Net, rng: &mut Rng) { } } for (a, b) in down { - if !net.is_up(a, b) { + if !is_up(net, a, b) { net.open(a, b); } } } -/// Every relay sits on a route of the best draining, priority, and cost among those -/// its neighbours last offered it, and the routes in use form trees: each one's -/// path is its next hop's route with that hop added. -fn check(net: &MultiSim, plan: &Net) -> Result<(), String> { +/// Whether `origin` is one of `router`'s own identities. +fn is_self(router: &Router, origin: NodeId) -> bool { + origin == router.me() || origin == router.me_marked() +} + +/// Every relay sits on a route of the best draining, priority, and cost among those its +/// neighbours last offered it, and the routes in use form trees: each one's path is its +/// next hop's route with that hop added. +fn check(net: &RelaySim, plan: &Net) -> Result<(), String> { for node in 0..plan.relays { let router = net.router(node).expect("a relay"); - for origin in router.origins() { - let candidates = router.candidates(origin); - let best = router.best(origin); - let lowest = candidates.iter().map(Best::rank).min(); - let Some(best) = best else { + for origin in router.heard() { + let candidates = router.usable(origin); + let lowest = candidates.iter().map(|best| best.offer.rank()).min(); + let Some((via, offer)) = router.best(origin) else { if lowest.is_some() { - return Err(format!("{node} uses no route to {origin} of {candidates:?}")); + return Err(format!("{node} uses no route to {origin:?} of {candidates:?}")); } continue; }; - if !candidates.contains(best) || Some(best.rank()) != lowest { - return Err(format!("{node} uses {best:?} to {origin} of {candidates:?}")); + let best = Best { + via, + offer: offer.clone(), + }; + if !candidates.contains(&best) || Some(offer.rank()) != lowest { + return Err(format!("{node} uses {best:?} to {origin:?} of {candidates:?}")); } - let path = &best.offer.path; - if path.len() > 1 { - let next = net.router(best.via).expect("a relay"); - let theirs = next.best(origin).map(|best| &best.offer.path[..]); - if theirs != Some(&path[..path.len() - 1]) { - return Err(format!( - "{node}'s route to {origin} is {path:?}; {} uses {theirs:?}", - best.via - )); - } + let next = net.router(via).expect("a relay"); + if is_self(next, origin) { + continue; + } + let path = &offer.path; + let theirs = next.best(origin).map(|(_, offer)| &offer.path[..]); + if theirs != Some(&path[..path.len() - 1]) { + return Err(format!( + "{node}'s route to {origin:?} is {path:?}; {via} uses {theirs:?}" + )); } } } Ok(()) } -/// The rule as it runs settles under any delivery order, through churn, on a -/// route of the best rank it was offered at every node. Which of two equal routes -/// it settles on varies with the order, but never its rank, its mark, or whether -/// it has one: only the next hop, which no neighbour's offer depends on. What can -/// vary is which relays announce at all (see -/// [`whether_a_relay_announces_hangs_on_arrival_order`]), so routes are compared -/// only to relays that announced in both orders. +/// The identities a relay announces a claim under, as of now. +fn announcing(router: &Router) -> Vec { + [router.me(), router.me_marked()] + .into_iter() + .filter(|id| router.own_as(*id).0 > 0) + .collect() +} + +/// The rule as it runs settles under any delivery order, through churn, on a route of +/// the best rank it was offered at every node. Which of two equal routes it settles on +/// varies with the order, but never its rank, its mark, or whether it has one: only the +/// next hop, which no neighbour's offer depends on. What can vary is which identities +/// announce at all (see [`whether_a_relay_announces_hangs_on_arrival_order`]), so routes +/// are compared only to identities that announced in both orders. #[test] fn the_next_hop_in_use_settles_on_a_best_rank() { let (mut settled, mut moved, mut ranked, mut marked, mut reached, mut announced) = (0, 0, 0, 0, 0, 0); @@ -211,44 +229,43 @@ fn the_next_hop_in_use_settles_on_a_best_rank() { } runs.push(net); } - let both: Vec = (0..plan.relays) - .filter(|&relay| { - let [a, b] = [&runs[0], &runs[1]].map(|net| net.router(relay).expect("a relay").announced()); - announced += usize::from(a != b); - a && b - }) - .map(|relay| hop(relay, 0)) - .collect(); + let mut both: Vec = Vec::new(); + for relay in 0..plan.relays { + let [a, b] = [&runs[0], &runs[1]].map(|net| announcing(net.router(relay).expect("a relay"))); + announced += a.iter().filter(|id| !b.contains(id)).count() + b.iter().filter(|id| !a.contains(id)).count(); + both.extend(a.iter().filter(|id| b.contains(id))); + } for node in 0..plan.relays { let [a, b] = [&runs[0], &runs[1]].map(|net| net.router(node).expect("a relay")); - for origin in both.iter().filter(|&&origin| origin != hop(node, 0)) { + for origin in both.iter().filter(|&&origin| !is_self(a, origin)) { settled += 1; let [x, y] = [a.best(*origin), b.best(*origin)]; - moved += usize::from(x.map(|x| x.via) != y.map(|y| y.via)); - ranked += usize::from(x.map(Best::rank) != y.map(Best::rank)); - marked += usize::from(x.map(|x| x.offer.marked) != y.map(|y| y.offer.marked)); + moved += usize::from(x.map(|x| x.0) != y.map(|y| y.0)); + ranked += usize::from(x.map(|x| x.1.rank()) != y.map(|y| y.1.rank())); + marked += usize::from(x.map(|x| x.1.marked) != y.map(|y| y.1.marked)); reached += usize::from(x.is_some() != y.is_some()); } } } println!( - "of {settled} routes settled twice: {moved} on another next hop, {ranked} at another rank, {marked} marked once, {reached} reachable once; {announced} relays announced in one order only" + "of {settled} routes settled twice: {moved} on another next hop, {ranked} at another rank, {marked} marked once, {reached} reachable once; {announced} identities announced in one order only" ); assert_eq!((ranked, marked, reached), (0, 0, 0)); assert!(moved > 0, "no two orders settled on different next hops"); } -/// Under `claimed` a relay offers a route to itself from its first claim on, for -/// good. Relay 2 has no endpoint: it can only announce a claim relay 1 grants it. -/// Relay 1 grants its closest claim, unless that is the one relay 2 granted it. 2's -/// grant, over 2's cheap route to 0, beats 1's own dear route. If 2's grant reaches -/// 1 first, 1 never grants 2 anything and 2 never announces. If 1 hears 0's claim -/// first, it grants it to 2, which announces; 1 then takes 2's cheaper grant and -/// withdraws its own, and 2 keeps a route to itself with no claim behind it. +/// A relay offers a route to itself from its first claim on, for good. Relay 2 has no +/// endpoint: it announces only a claim it adopts across its scoped grant to relay 1, and 1 +/// tells 2 its closest claim unless that is the one 2 told it. 2 tells 1 publisher 3's +/// claim, which 2 reaches over its cheap route to 0, and 1 adopts it, which beats 1's +/// own dear route to 0. If 2's grant reaches 1 first, 1's closest claim is the one 2 +/// gave it, so 1 tells 2 nothing and 2 never announces. If 1 hears 0's claim first, it +/// tells it to 2, which announces it; 1 then adopts 2's cheaper grant and withdraws what +/// it told, and 2 keeps a route to itself with no claim behind it. #[test] fn whether_a_relay_announces_hangs_on_arrival_order() { let build = || { - let mut net = MultiSim::new(KEPT, 4); + let mut net = RelaySim::new(4, relay::debounce(HOP)); net.client(3); net.publish(3, 100); net.link(3, 0, 1, Tie::Peer); @@ -265,25 +282,28 @@ fn whether_a_relay_announces_hangs_on_arrival_order() { assert!(settle(&mut net, &mut rng)); net.release(late.0, late.1); assert!(settle(&mut net, &mut rng)); + while net.tick() {} + assert!(settle(&mut net, &mut rng)); + let id = net.id(2); let relay = net.router(2).expect("a relay"); - let claimed = relay.step(hop(2, 0), &(100, p("live/0"))).is_some(); - let routed = net.router(0).expect("a relay").best(hop(2, 0)).is_some(); + let claimed = relay.own().1.contains_key(&(p("live/0"), 100)); + let routed = net.router(0).expect("a relay").best(id).is_some(); (relay.announced(), claimed, routed) }; assert_eq!(settled((0, 1)), (false, false, false), "2's grant first"); assert_eq!(settled((2, 1)), (true, false, true), "0's claim first at 1"); } -/// A route learned over an upstream link is marked, and a marked route is never -/// sent over another upstream link. Relay 3 hears two routes of equal rank to -/// relay 0: through 2, over a link it marked upstream, and through 1, over a peer -/// link. Were the mark below the next hop in use, 3 would keep whichever came -/// first, and with 2's first 4 would be offered nothing. Unmarked first, 3 moves to -/// 1's route whichever came first, and offers it to 4, its own upstream. +/// A route learned over an upstream link is marked, and a marked route is never sent over +/// another upstream link. Relay 3 hears two routes of equal rank to relay 0: through 2, +/// over a link it marked upstream, and through 1, over a peer link. Were the mark below +/// the next hop in use, 3 would keep whichever came first, and with 2's first 4 would be +/// offered nothing. Unmarked first, 3 moves to 1's route whichever came first, and offers +/// it to 4, its own upstream. #[test] fn an_equal_route_in_use_never_leaves_a_neighbour_without_one() { let build = || { - let mut net = MultiSim::new(KEPT, 6); + let mut net = RelaySim::new(6, relay::debounce(HOP)); net.client(5); net.publish(5, 100); net.link(5, 0, 1, Tie::Peer); @@ -294,44 +314,23 @@ fn an_equal_route_in_use_never_leaves_a_neighbour_without_one() { net.link(3, 4, 1, Tie::Up); net }; - let origin = hop(0, 0); let mut rng = Rng(7); let mut settled = |first: Node, second: Node| { let mut net = build(); + let origin = net.id(0); net.hold(second, 3); net.claim(5, "live/0", true); assert!(settle(&mut net, &mut rng)); assert_eq!( - net.router(3).and_then(|r| r.best(origin)).map(|best| best.via), + net.router(3).and_then(|r| r.best(origin)).map(|(via, _)| via), Some(first) ); net.release(second, 3); assert!(settle(&mut net, &mut rng)); - let via = net.router(3).and_then(|r| r.best(origin)).map(|best| best.via); + let via = net.router(3).and_then(|r| r.best(origin)).map(|(via, _)| via); let reached = net.router(4).and_then(|r| r.best(origin)).is_some(); (via, reached) }; assert_eq!(settled(1, 2), (Some(1), true), "the unmarked route first"); assert_eq!(settled(2, 1), (Some(1), true), "the marked route first"); } - -/// A request may take any next hop tied with the route in use, and a marked route -/// does not tie with an unmarked one of the same rank: taking it would carry a copy -/// between two upstreams, which the route in use never does. -#[test] -fn a_marked_route_does_not_tie_with_an_unmarked_one() { - let mut net = MultiSim::new(KEPT, 6); - net.client(5); - net.publish(5, 100); - net.link(5, 0, 1, Tie::Peer); - net.link(0, 1, 1, Tie::Peer); - net.link(0, 2, 1, Tie::Peer); - net.link(3, 2, 1, Tie::Up); - net.link(3, 1, 1, Tie::Peer); - net.claim(5, "live/0", true); - assert!(settle(&mut net, &mut Rng(7))); - let router = net.router(3).expect("relay 3"); - let origin = hop(0, 0); - assert_eq!(router.candidates(origin).len(), 2, "both routes are heard"); - assert_eq!(router.ties(origin), vec![1]); -} diff --git a/rs/moq-net/verify/README.md b/rs/moq-net/verify/README.md index 5f05da964dd..321427c1746 100644 --- a/rs/moq-net/verify/README.md +++ b/rs/moq-net/verify/README.md @@ -12,9 +12,9 @@ After a change to a covered function, mirror it in the model, rerun every config ## The route proof -`route-algebra/` is not a model check: it states the multicast route rule as an increasing path algebra in Agda and applies Daggitt and Griffin's convergence theorem to it, checked nightly by `just test route-proof`. Its [README](route-algebra/README.md) holds the full coverage and the paper arguments. In short: +`route-algebra/` is not a model check: it states the route rule `route::relay::Router` runs, and its claims, as increasing path algebras in Agda and applies Daggitt and Griffin's convergence theorem to it, checked nightly by `just test route-proof`. Its [README](route-algebra/README.md) holds the full coverage and the paper arguments. In short: - Mechanized: the rule converges on every network, from every state, under loss, reordering, and duplication, to one fixed point, with ties broken by one fixed order, provided every node keeps acting and keeps hearing newer messages from each neighbour while the network holds still; the same for claims across trust boundaries; and the floor and the named drains leave that fixed point unchanged. -- Tested against the proof: the prototype's rank and extend functions meet its axioms, and 322 of their results are checked by Agda. +- Tested against the proof: the router's own rank, extend, and refuse functions for routes and claims meet its axioms, and 656 of their results are checked by Agda. - On paper and tested, not mechanized: the rule as it runs puts the next hop in use ahead of the shorter path and the neighbour, so its stable state is not unique. It still settles, and every node settles on the rank and mark the fixed order gives it, except where a longer path meets the 32-hop limit; only the next hop varies. -- Not given: loop freedom at every instant, warmth (`verify-warm` model-checks that warm pulls settle), liveness under endless churn, the chain as Rust records it, and which relays announce under `claimed`. +- Not given: the router's state machine around those functions, loop freedom at every instant, warmth (`verify-warm` model-checks that warm pulls settle), liveness under endless churn, the chain inside a domain, which claims a node knows of and which relays announce (both taken as labels fixed within an epoch), two sessions to one neighbour, and a claim cost saturated at the metric. diff --git a/rs/moq-net/verify/route-algebra/Accelerate.agda b/rs/moq-net/verify/route-algebra/Accelerate.agda index 1e53eba1e2c..5a81c9590e4 100644 --- a/rs/moq-net/verify/route-algebra/Accelerate.agda +++ b/rs/moq-net/verify/route-algebra/Accelerate.agda @@ -16,10 +16,7 @@ open import Data.Nat.Base using (ℕ) open import Relation.Binary.PropositionalEquality using (_≡_) -module Accelerate - (relay start : ℕ → ℕ) - (relay-start-injective : ∀ {m n} → relay m ≡ relay n → start m ≡ start n → m ≡ n) - where +module Accelerate (relay start mark : ℕ → ℕ) where open import Data.Bool.Base using (Bool; true; false; _∨_; _∧_; not) import Data.Bool.Properties as Bool @@ -28,7 +25,7 @@ open import Data.List.Base using (List; []; _∷_; map; any; zip; length; foldr; open import Data.List.Properties using (tabulate-cong) open import Data.List.Relation.Unary.All using (All; []; _∷_) import Data.List.Relation.Unary.All as All -open import Data.Nat.Base using (zero; suc; _<_; _≤ᵇ_) +open import Data.Nat.Base using (zero; suc; _+_; _<_; _≤ᵇ_; _<ᵇ_) import Data.Nat.Properties as ℕ open import Data.Product.Base using (_×_; _,_; ∃₂; proj₁; proj₂) open import Data.Sum.Base using (_⊎_; inj₁; inj₂) @@ -40,7 +37,7 @@ open import RoutingLib.Routing.Basics.Path.Uncertified using (Path; Edge) open import RoutingLib.Routing.Basics.Path.Uncertified.Properties using (_⇿?_; _∈ₚ?_) open import RoutingLib.Routing.Basics.Network using (AdjacencyMatrix) -open import Route relay start relay-start-injective +open import Route relay start mark private -- A link refuses every route while it is down. @@ -186,7 +183,8 @@ module _ {n : ℕ} (A : AdjacencyMatrix algebra n) where where prefix : Bool → Bool prefix b = not (Link.up (A i k)) ∨ (null (path x) ∧ not (Link.claimed (A i k))) - ∨ (marked x ∧ Link.marked-there (A i k)) ∨ (max-hops ≤ᵇ suc (length (path x))) ∨ b + ∨ (marked x ∧ Link.marked-there (A i k)) ∨ (max-hops ≤ᵇ suc (length (path x))) + ∨ (metric <ᵇ Link.cost (A i k) + cost x) ∨ elsewhere (toℕ i , toℕ k) (path x) ∨ b -- One step across a link of A takes a sound route as `plain` does. neutral : ∀ i k w → Sound w → extend (A i k) (toℕ i , toℕ k) w ≡ extend (plain i k) (toℕ i , toℕ k) w @@ -197,7 +195,7 @@ module _ {n : ℕ} (A : AdjacencyMatrix algebra n) where ... | yes _ | yes _ = refl ... | yes _ | no _ rewrite same-refusal i k x holds with refuses (plain i k) (toℕ i , toℕ k) x in eq ... | true = refl - ... | false rewrite no-drain (map proj₂ (path x)) = cong (λ d → valid (route d _ _ _ _ _)) drained + ... | false rewrite no-drain (map proj₂ (path x)) = cong (λ d → valid (route _ d _ _ _ _ _)) drained where up = refuses-up (plain i k) (toℕ i , toℕ k) x eq -- What the drains add, given the route is already draining where they would. diff --git a/rs/moq-net/verify/route-algebra/Claim.agda b/rs/moq-net/verify/route-algebra/Claim.agda index fe3d92dfaec..1d3162aad9d 100644 --- a/rs/moq-net/verify/route-algebra/Claim.agda +++ b/rs/moq-net/verify/route-algebra/Claim.agda @@ -1,62 +1,169 @@ -------------------------------------------------------------------------------- --- Claims across trust boundaries: the same algebra at the grain of the nodes --- that hand a claim on. +-- Claims across trust boundaries: the same algebra at the grain of the relays +-- that hand a claim on, as `route::relay::Router` ranks and passes claims. -- --- A claim's route is its draining, penalty, and cost from the publisher, and the --- path of nodes that handed it on. A link here is a step a claim takes: from an --- endpoint to the relay announcing it, from a node to the claim of an announcer --- in its routing domain over the node's settled route there, or across a scoped --- grant. Each step only adds: it may make the claim draining, raise its penalty, --- add cost, and prepends the node that took it, which refuses a claim that names --- it already. How Rust's claims map onto this, and where Rust's chain names fewer --- nodes than this path, is in this directory's `README.md`. +-- The destination is a broadcast: one Instance at one path. A claim's route to it +-- carries the claim's precedence, its draining, penalty, and cost, whether a +-- marked link reached it, the path of relays that handed it on, and whom its +-- holder files it under. A step is one of: +-- +-- * the publisher's own, from the publisher to the broadcast, which sets its run; +-- * an adoption: a relay takes the claim from an endpoint or across a scoped +-- grant (`Claim::adopted`), after its giver told it (`Claim::exported`), which +-- adds the link's cost and priority, marks it where the relay marked the link, +-- lowers it where it is shown below its own path, and refuses one the giver +-- marked the link against, as the giver tells it no such claim, and one whose +-- path reaches the longest chain; the relay files it under itself, or under its +-- marked identity once a marked link reached it; +-- * a domain step: a relay takes the claim of an announcer in its routing domain +-- over its settled route there (`Claim::over`). +-- +-- Precedence leads: a claim exactly at its path before a broader one shown there, +-- then the newer run. Every step into a node refuses a claim below the best +-- precedence the node knows of, reachable or not (`top`), so the rank chooses only +-- among claims of that precedence. Then, as `claim_order` keys them: the rank, one +-- no marked link reached, the shorter path, the claimant's Node ID, and the key the +-- holder gives the neighbour that gave it. How Rust's chain maps onto the path, +-- and where it names fewer relays, is in this directory's `README.md`. -------------------------------------------------------------------------------- module Claim where -open import Data.Bool.Base using (Bool; true; false; not) -open import Data.Nat.Base using (ℕ) -open import Data.Unit.Base using (⊤; tt) -import Data.Unit.Properties as Unit -open import Relation.Binary.PropositionalEquality using (_≡_; refl) +open import Data.Bool.Base using (Bool; true; false; _∨_; _∧_; not; if_then_else_) +open import Data.List.Base using (List; []; length) +open import Data.Maybe.Base using (Maybe; nothing; just) +open import Data.Nat.Base using (ℕ; _+_; _≤ᵇ_; z≤n) +import Data.Nat.Properties as ℕ +open import Data.Product.Base using (_×_; _,_; proj₁; proj₂) +open import Data.Sum.Base using (inj₁) +open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong) +open import Relation.Nullary.Decidable.Core using (does) -open import RoutingLib.Routing.Basics.Path.Uncertified.Properties using (≤ₗₑₓ-isDecTotalOrder) +open import RoutingLib.Routing.Basics.Path.Uncertified using (Path; Edge) open import Order +------------------------------------------------------------------------ +-- What leads the rank + +-- How far below its own path the claim is shown, and its run. +Precedence : Set +Precedence = ℕ × Maybe ℕ + +OC : Ordered Precedence +OC = lex nat runs + +private + none-least : ∀ r → Ordered._≤_ runs nothing r + none-least nothing = Ordered.refl runs {nothing} + none-least (just _) = inj₁ (z≤n , λ ()) + + c₀-least : ∀ c → Ordered._≤_ OC (0 , nothing) c + c₀-least (a , r) = lex-≤ nat runs {0} {a} {nothing} {r} z≤n λ _ → none-least r + +------------------------------------------------------------------------ +-- What else a claim carries + +-- A Node ID: relay, start, and 1 for a marked identity. +Who : Set +Who = ℕ × ℕ × ℕ + +-- The claimant, and the key its holder gives the neighbour that gave it. +Extra : Set +Extra = Who × ℕ + private - OE : Ordered ⊤ - OE = record { _≤_ = _≡_ ; isDecTotalOrder = Unit.≡-isDecTotalOrder } + OE : Ordered Extra + OE = lex (lex nat (lex nat nat)) nat - -- Among equal ranks and lengths, by the nodes on the path, nearest first. - OP = record { _≤_ = _ ; isDecTotalOrder = ≤ₗₑₓ-isDecTotalOrder } + e₀ : Extra + e₀ = (0 , 0 , 0) , 0 -open import Increasing OE tt (λ _ → refl) OP public + e₀-least : ∀ e → Ordered._≤_ OE e₀ e + e₀-least ((_ , _ , _) , _) = + lex-≤ (lex nat (lex nat nat)) nat (lex-≤ nat (lex nat nat) z≤n λ _ → lex-≤ nat nat z≤n λ _ → z≤n) λ _ → z≤n + + -- Among equal ranks, marks, and lengths, by claimant and giver: one claimant has one + -- claim of a broadcast, and one holder takes it from a giver once, so the path never + -- decides between candidates at a node. + OT : Ordered (Path × Extra) + OT = keyed (λ (p , e) → e , p) (cong (λ (e , p) → p , e)) (lex OE (list (lex nat nat))) + + OT-least : ∀ e → Ordered._≤_ OT ([] , e₀) ([] , e) + OT-least e = lex-≤ OE (list (lex nat nat)) (e₀-least e) λ _ → Ordered.refl (list (lex nat nat)) + +open import Increasing OC (0 , nothing) c₀-least e₀ OT OT-least public + +------------------------------------------------------------------------ +-- A step + +-- A path that reaches this length at a giver is never adopted (`MAX_HOPS`). +max-chain : ℕ +max-chain = 32 --- One step a claim can take. record Step : Set where constructor step field - up : Bool - cost : ℕ - penalty : ℕ - drains : Bool + up : Bool + cost : ℕ + penalty : ℕ -- 127 minus the link's or route's priority + drains : Bool -- the giver sent GOAWAY, or the route is draining + marked-here : Bool -- the receiver marked the link, or the route crossed a marked one + marked-there : Bool -- the giver marked the link + adopts : Bool -- an adoption, not a domain step + lowered : ℕ -- how far below the claim's path the receiver is shown it + run : Maybe ℕ -- the publisher's run, on its own step + top : Precedence -- the best precedence the receiver knows of, reachable or not + me : ℕ × ℕ -- the receiver's relay and start + giver : ℕ -- the receiver's key for the giver private module S = Step + first : Maybe ℕ → Maybe ℕ → Maybe ℕ + first nothing r = r + first (just n) _ = just n + + rise : Step → Precedence → Precedence + rise f (a , r) = a + S.lowered f , first r (S.run f) + + rise-≥ : ∀ f c → Ordered._≤_ OC c (rise f c) + rise-≥ f (a , nothing) = + lex-≤ nat runs {a} {a + S.lowered f} {nothing} {S.run f} (ℕ.m≤m+n a (S.lowered f)) λ _ → none-least (S.run f) + rise-≥ f (a , just n) = + lex-≤ nat runs {a} {a + S.lowered f} {just n} {just n} (ℕ.m≤m+n a (S.lowered f)) λ _ → Ordered.refl runs {just n} + +-- A step refuses a claim when it is down, when the claim crossed a marked link and +-- the giver marked this one, when an adoption would take a path at the longest +-- chain, or when the receiver knows a claim of better precedence. +refuses : Step → Edge → Valid → Bool +refuses f _ v = + not (S.up f) + ∨ (marked v ∧ S.marked-there f) + ∨ (S.adopts f ∧ (max-chain ≤ᵇ length (path v))) + ∨ not (does (Ordered._≤?_ OC (rise f (lead v)) (S.top f))) + +-- An adoption files the claim under the receiver, marked once a marked link reached +-- it; a domain step keeps the announcer's claimant. +tag : Step → Edge → Valid → Extra +tag f _ v with S.adopts f +... | true = (proj₁ (S.me f) , proj₂ (S.me f) , (if marked v ∨ S.marked-here f then 1 else 0)) , S.giver f +... | false = proj₁ (extra v) , 0 + policy : Policy policy = record { Link = Step - ; down = step false 0 0 false + ; down = step false 0 0 false false false false 0 nothing (0 , nothing) (0 , 0) 0 + ; rise = rise + ; rise-≥ = rise-≥ ; cost = S.cost ; penalty = S.penalty ; drains = S.drains ; marks = λ _ _ _ → false - ; marked = λ _ → false - ; refuses = λ f _ _ → not (S.up f) + ; marked = S.marked-here + ; refuses = refuses ; down-refuses = λ _ _ → refl - ; tag = λ _ _ → tt + ; tag = tag } open Rule policy public diff --git a/rs/moq-net/verify/route-algebra/ClaimVectors.agda b/rs/moq-net/verify/route-algebra/ClaimVectors.agda new file mode 100644 index 00000000000..28251f86f3a --- /dev/null +++ b/rs/moq-net/verify/route-algebra/ClaimVectors.agda @@ -0,0 +1,1412 @@ +-- Generated by `rs/moq-net/src/route/tests/algebra.rs` (`ROUTE_VECTORS=write`); do not edit. +-- Each case is a result `route::relay::Router` computed of a claim, which the algebra must compute too. + +module ClaimVectors where + +open import Data.Bool.Base using (true; false) +open import Data.List.Base using ([]; _∷_) +open import Data.Maybe.Base using (nothing; just) +open import Data.Product.Base using (_,_) +open import Relation.Binary.PropositionalEquality using (_≡_; refl) + +open import Claim + +_ : extend (step true 4 127 true false false false 0 nothing (1 , just 2) (4 , 2) 0) (4 , 3) (valid (route (1 , just 2) true 127 5 false ((3 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 8))) + ≡ valid (route (1 , just 2) true 127 9 false ((4 , 3) ∷ (3 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 11 128 false false false false 0 nothing (0 , just 0) (6 , 1) 0) (6 , 8) (valid (route (0 , just 0) false 127 4 false ((8 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 8))) + ≡ valid (route (0 , just 0) false 128 15 false ((6 , 8) ∷ (8 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 3 128 false false false true 0 nothing (0 , just 0) (5 , 1) 7) (5 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 128 3 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 7)) +_ = refl + +_ : extend (step true 2 127 false false false true 0 nothing (1 , just 1) (6 , 1) 2) (6 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) false 127 2 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 2)) +_ = refl + +_ : extend (step true 1 255 true true false false 0 nothing (0 , just 2) (5 , 1) 0) (5 , 4) (valid (route (1 , just 2) true 0 4 true ((4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 1) , 7))) + ≡ invalid +_ = refl + +_ : extend (step true 3 122 false true false true 0 nothing (0 , just 1) (7 , 1) 5) (7 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) false 122 3 true ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 1) , 5)) +_ = refl + +_ : extend (step true 4 128 false false false true 0 nothing (1 , just 2) (8 , 2) 2) (8 , 1) (valid (route (0 , just 2) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 2) false 128 4 false ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 0) , 2)) +_ = refl + +_ : extend (step true 1 127 false true false false 0 nothing (2 , just 2) (3 , 1) 0) (3 , 8) (valid (route (1 , just 2) true 128 10 true ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 1) , 3))) + ≡ valid (route (1 , just 2) true 128 11 true ((3 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 9 122 false false false false 0 nothing (0 , just 2) (3 , 1) 0) (3 , 4) (valid (route (0 , just 2) false 128 9 false ((4 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 0) , 4))) + ≡ valid (route (0 , just 2) false 128 18 false ((3 , 4) ∷ (4 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 1 127 false false true true 0 nothing (1 , just 0) (8 , 2) 7) (8 , 3) (valid (route (1 , just 0) false 255 3 true ((3 , 9) ∷ (9 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 2))) + ≡ invalid +_ = refl + +_ : extend (step true 4 128 true true false true 0 nothing (0 , just 2) (3 , 2) 3) (3 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 4 255 false false false false 0 nothing (1 , just 1) (5 , 1) 0) (5 , 2) (valid (route (1 , just 1) false 0 3 false ((2 , 3) ∷ (3 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 9))) + ≡ valid (route (1 , just 1) false 255 7 false ((5 , 2) ∷ (2 , 3) ∷ (3 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 2 128 false true false true 0 nothing (0 , just 0) (4 , 1) 2) (4 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 128 2 true ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 1) , 2)) +_ = refl + +_ : extend (step true 4 0 false false false true 0 nothing (0 , just 2) (8 , 2) 4) (8 , 1) (valid (route (0 , just 2) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 2) false 0 4 false ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 0) , 4)) +_ = refl + +_ : extend (step true 4 255 false false false true 1 nothing (1 , just 1) (9 , 2) 6) (9 , 4) (valid (route (0 , just 1) true 122 7 false ((4 , 2) ∷ (2 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 9))) + ≡ valid (route (1 , just 1) true 255 11 false ((9 , 4) ∷ (4 , 2) ∷ (2 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 6)) +_ = refl + +_ : extend (step true 10 255 false false false false 0 nothing (1 , just 2) (8 , 2) 0) (8 , 4) (valid (route (1 , just 2) false 122 9 true ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 1) , 7))) + ≡ valid (route (1 , just 2) false 255 19 true ((8 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 1 255 true false true true 0 nothing (1 , just 2) (4 , 1) 8) (4 , 6) (valid (route (1 , just 0) true 128 12 true ((6 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 10 127 false false false false 0 nothing (1 , just 1) (5 , 1) 0) (5 , 2) (valid (route (0 , just 1) false 127 7 true ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 2))) + ≡ valid (route (0 , just 1) false 127 17 true ((5 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 2 0 false true false true 0 nothing (0 , just 2) (6 , 1) 7) (6 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 8 127 false true false false 0 nothing (1 , just 1) (2 , 1) 0) (2 , 9) (valid (route (1 , just 1) false 128 3 false ((9 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 2))) + ≡ valid (route (1 , just 1) false 128 11 true ((2 , 9) ∷ (9 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 4 127 false false false false 0 nothing (0 , just 1) (7 , 2) 0) (7 , 6) (valid (route (0 , just 0) false 128 0 false ((6 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 2))) + ≡ invalid +_ = refl + +_ : extend (step true 4 127 false false true true 1 nothing (0 , just 1) (7 , 2) 8) (7 , 8) (valid (route (1 , just 0) true 127 8 true ((8 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 1) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 3 255 false false false true 1 nothing (1 , just 2) (3 , 2) 7) (3 , 2) (valid (route (0 , just 2) true 255 0 false ((2 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 7))) + ≡ valid (route (1 , just 2) true 255 3 false ((3 , 2) ∷ (2 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 7)) +_ = refl + +_ : extend (step true 12 0 true true false false 0 nothing (1 , just 0) (6 , 1) 0) (6 , 7) (valid (route (0 , just 0) false 127 3 false ((7 , 4) ∷ (4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 3))) + ≡ valid (route (0 , just 0) true 127 15 true ((6 , 7) ∷ (7 , 4) ∷ (4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 2 255 false false false true 0 nothing (0 , just 1) (7 , 2) 2) (7 , 5) (valid (route (0 , just 0) false 255 11 false ((5 , 2) ∷ (2 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 5))) + ≡ invalid +_ = refl + +_ : extend (step true 7 122 false false false false 0 nothing (0 , just 0) (5 , 2) 0) (5 , 3) (valid (route (1 , just 0) true 128 10 false ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 7))) + ≡ invalid +_ = refl + +_ : extend (step true 4 255 false true false true 0 nothing (0 , just 2) (6 , 2) 6) (6 , 1) (valid (route (0 , just 2) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 2) false 255 4 true ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 6)) +_ = refl + +_ : extend (step true 2 255 false false false true 0 nothing (0 , just 2) (3 , 2) 7) (3 , 1) (valid (route (0 , just 2) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 2) false 255 2 false ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 7)) +_ = refl + +_ : extend (step true 11 255 false false false false 0 nothing (0 , just 2) (5 , 1) 0) (5 , 9) (valid (route (0 , just 2) false 127 3 false ((9 , 2) ∷ (2 , 13) ∷ (13 , 23) ∷ (23 , 56) ∷ (56 , 11) ∷ (11 , 31) ∷ (31 , 58) ∷ (58 , 6) ∷ (6 , 55) ∷ (55 , 49) ∷ (49 , 30) ∷ (30 , 18) ∷ (18 , 57) ∷ (57 , 21) ∷ (21 , 26) ∷ (26 , 7) ∷ (7 , 41) ∷ (41 , 25) ∷ (25 , 39) ∷ (39 , 34) ∷ (34 , 22) ∷ (22 , 47) ∷ (47 , 44) ∷ (44 , 43) ∷ (43 , 15) ∷ (15 , 29) ∷ (29 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 8))) + ≡ valid (route (0 , just 2) false 255 14 false ((5 , 9) ∷ (9 , 2) ∷ (2 , 13) ∷ (13 , 23) ∷ (23 , 56) ∷ (56 , 11) ∷ (11 , 31) ∷ (31 , 58) ∷ (58 , 6) ∷ (6 , 55) ∷ (55 , 49) ∷ (49 , 30) ∷ (30 , 18) ∷ (18 , 57) ∷ (57 , 21) ∷ (21 , 26) ∷ (26 , 7) ∷ (7 , 41) ∷ (41 , 25) ∷ (25 , 39) ∷ (39 , 34) ∷ (34 , 22) ∷ (22 , 47) ∷ (47 , 44) ∷ (44 , 43) ∷ (43 , 15) ∷ (15 , 29) ∷ (29 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 3 255 false false true true 1 nothing (0 , just 2) (4 , 2) 1) (4 , 6) (valid (route (0 , just 1) true 255 16 true ((6 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 1) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 1 122 true true false true 1 nothing (1 , just 1) (4 , 2) 2) (4 , 8) (valid (route (0 , just 1) false 255 9 true ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 1) , 1))) + ≡ valid (route (1 , just 1) true 255 10 true ((4 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 1) , 2)) +_ = refl + +_ : extend (step true 2 255 false true true true 1 nothing (1 , just 1) (2 , 2) 5) (2 , 3) (valid (route (0 , just 1) false 122 15 false ((3 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 0))) + ≡ valid (route (1 , just 1) false 255 17 true ((2 , 3) ∷ (3 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 5)) +_ = refl + +_ : extend (step true 4 128 false false false true 0 nothing (1 , just 1) (3 , 1) 2) (3 , 5) (valid (route (1 , just 1) true 255 8 false ((5 , 6) ∷ (6 , 8) ∷ (8 , 28) ∷ (28 , 15) ∷ (15 , 55) ∷ (55 , 29) ∷ (29 , 42) ∷ (42 , 22) ∷ (22 , 60) ∷ (60 , 52) ∷ (52 , 61) ∷ (61 , 9) ∷ (9 , 25) ∷ (25 , 23) ∷ (23 , 11) ∷ (11 , 4) ∷ (4 , 18) ∷ (18 , 35) ∷ (35 , 32) ∷ (32 , 38) ∷ (38 , 19) ∷ (19 , 12) ∷ (12 , 41) ∷ (41 , 7) ∷ (7 , 39) ∷ (39 , 57) ∷ (57 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 0))) + ≡ valid (route (1 , just 1) true 255 12 false ((3 , 5) ∷ (5 , 6) ∷ (6 , 8) ∷ (8 , 28) ∷ (28 , 15) ∷ (15 , 55) ∷ (55 , 29) ∷ (29 , 42) ∷ (42 , 22) ∷ (22 , 60) ∷ (60 , 52) ∷ (52 , 61) ∷ (61 , 9) ∷ (9 , 25) ∷ (25 , 23) ∷ (23 , 11) ∷ (11 , 4) ∷ (4 , 18) ∷ (18 , 35) ∷ (35 , 32) ∷ (32 , 38) ∷ (38 , 19) ∷ (19 , 12) ∷ (12 , 41) ∷ (41 , 7) ∷ (7 , 39) ∷ (39 , 57) ∷ (57 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 0) , 2)) +_ = refl + +_ : extend (step true 3 122 true true false false 0 nothing (1 , just 2) (6 , 2) 0) (6 , 5) (valid (route (1 , just 2) false 128 4 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 5))) + ≡ valid (route (1 , just 2) true 128 7 true ((6 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 3 122 false true false true 0 nothing (0 , just 1) (8 , 2) 7) (8 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) false 122 3 true ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 1) , 7)) +_ = refl + +_ : extend (step true 7 122 false false false false 0 nothing (0 , just 0) (3 , 2) 0) (3 , 2) (valid (route (0 , just 0) true 0 5 true ((2 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 7))) + ≡ valid (route (0 , just 0) true 122 12 true ((3 , 2) ∷ (2 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 8 122 false true false false 0 nothing (0 , just 2) (8 , 2) 0) (8 , 7) (valid (route (0 , just 2) false 127 3 true ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 1) , 8))) + ≡ valid (route (0 , just 2) false 127 11 true ((8 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 2 128 false false false true 0 nothing (1 , just 0) (3 , 1) 5) (3 , 5) (valid (route (1 , just 0) true 128 10 true ((5 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 1) , 6))) + ≡ valid (route (1 , just 0) true 128 12 true ((3 , 5) ∷ (5 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 5)) +_ = refl + +_ : extend (step true 2 122 false false false true 0 nothing (0 , just 1) (7 , 2) 8) (7 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) false 122 2 false ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 8)) +_ = refl + +_ : extend (step true 4 122 false true true true 1 nothing (3 , just 2) (6 , 1) 9) (6 , 7) (valid (route (1 , just 2) false 0 6 false ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 2))) + ≡ valid (route (2 , just 2) false 122 10 true ((6 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 1) , 9)) +_ = refl + +_ : extend (step true 8 0 false false false false 0 nothing (1 , just 2) (6 , 2) 0) (6 , 2) (valid (route (1 , just 2) false 122 8 false ((2 , 8) ∷ (8 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 9))) + ≡ valid (route (1 , just 2) false 122 16 false ((6 , 2) ∷ (2 , 8) ∷ (8 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 7 128 false false false false 0 nothing (0 , just 1) (5 , 2) 0) (5 , 6) (valid (route (1 , just 1) false 122 6 false ((6 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 2))) + ≡ invalid +_ = refl + +_ : extend (step true 4 255 true false false true 0 nothing (0 , just 3) (4 , 1) 4) (4 , 1) (valid (route (0 , just 2) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 9 122 true true false false 0 nothing (1 , just 1) (5 , 1) 0) (5 , 9) (valid (route (1 , just 1) true 0 7 false ((9 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 7))) + ≡ valid (route (1 , just 1) true 122 16 true ((5 , 9) ∷ (9 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 3 127 false false true true 0 nothing (1 , just 2) (2 , 2) 7) (2 , 4) (valid (route (1 , just 0) false 0 20 true ((4 , 3) ∷ (3 , 5) ∷ (5 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 1) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 2 127 false false false true 0 nothing (0 , just 2) (4 , 2) 2) (4 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 4 122 false true false false 0 nothing (1 , just 0) (2 , 2) 0) (2 , 6) (valid (route (1 , just 0) false 122 8 false ((6 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 2))) + ≡ valid (route (1 , just 0) false 122 12 true ((2 , 6) ∷ (6 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 9 128 false false false false 0 nothing (1 , just 1) (4 , 2) 0) (4 , 3) (valid (route (1 , just 1) false 0 7 true ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 8))) + ≡ valid (route (1 , just 1) false 128 16 true ((4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 6 0 true true false false 0 nothing (0 , just 2) (2 , 1) 0) (2 , 3) (valid (route (0 , just 2) false 127 1 true ((3 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 4))) + ≡ valid (route (0 , just 2) true 127 7 true ((2 , 3) ∷ (3 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 6 122 false false false false 0 nothing (0 , just 0) (4 , 1) 0) (4 , 3) (valid (route (0 , just 0) false 122 5 true ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 9))) + ≡ valid (route (0 , just 0) false 122 11 true ((4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 4 128 false false false true 0 nothing (0 , just 0) (3 , 2) 2) (3 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 128 4 false ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 2)) +_ = refl + +_ : extend (step true 2 128 false false false false 0 nothing (2 , just 1) (6 , 2) 0) (6 , 8) (valid (route (1 , just 1) false 122 10 true ((8 , 2) ∷ (2 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 1) , 9))) + ≡ valid (route (1 , just 1) false 128 12 true ((6 , 8) ∷ (8 , 2) ∷ (2 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 1 0 true true false false 0 nothing (1 , just 1) (2 , 1) 0) (2 , 9) (valid (route (1 , just 1) false 127 6 false ((9 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 3))) + ≡ valid (route (1 , just 1) true 127 7 true ((2 , 9) ∷ (9 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 6 128 false true false false 0 nothing (0 , just 2) (4 , 2) 0) (4 , 2) (valid (route (0 , just 1) false 255 11 true ((2 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 2))) + ≡ invalid +_ = refl + +_ : extend (step true 1 255 true false true true 0 nothing (0 , just 1) (8 , 1) 3) (8 , 6) (valid (route (0 , just 1) true 255 7 false ((6 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 3))) + ≡ valid (route (0 , just 1) true 255 8 false ((8 , 6) ∷ (6 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 3)) +_ = refl + +_ : extend (step true 1 0 true true false true 0 nothing (1 , just 0) (9 , 2) 5) (9 , 5) (valid (route (0 , just 0) true 122 8 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 2))) + ≡ valid (route (0 , just 0) true 122 9 true ((9 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 1) , 5)) +_ = refl + +_ : extend (step true 4 122 false false false true 0 nothing (0 , just 0) (8 , 2) 7) (8 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 122 4 false ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 0) , 7)) +_ = refl + +_ : extend (step true 3 255 true false false true 0 nothing (0 , just 0) (8 , 1) 1) (8 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) true 255 3 false ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 1)) +_ = refl + +_ : extend (step true 1 255 false true false false 0 nothing (1 , just 2) (7 , 2) 0) (7 , 9) (valid (route (1 , just 2) true 122 6 true ((9 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 1) , 3))) + ≡ valid (route (1 , just 2) true 255 7 true ((7 , 9) ∷ (9 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 1 127 true false false true 0 nothing (0 , just 0) (5 , 2) 9) (5 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) true 127 1 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 9)) +_ = refl + +_ : extend (step true 10 128 false false false false 0 nothing (0 , just 2) (7 , 1) 0) (7 , 8) (valid (route (1 , just 2) false 255 9 false ((8 , 6) ∷ (6 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 0) , 8))) + ≡ invalid +_ = refl + +_ : extend (step true 2 122 false false false true 0 nothing (0 , just 2) (5 , 2) 2) (5 , 1) (valid (route (0 , just 2) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 2) false 122 2 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 2)) +_ = refl + +_ : extend (step true 2 0 false true false true 0 nothing (0 , just 2) (4 , 2) 2) (4 , 1) (valid (route (0 , just 2) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 2) false 0 2 true ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 1) , 2)) +_ = refl + +_ : extend (step true 3 128 false false false true 0 nothing (1 , just 0) (2 , 1) 9) (2 , 4) (valid (route (1 , just 0) false 122 11 false ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 0) , 1))) + ≡ valid (route (1 , just 0) false 128 14 false ((2 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 9)) +_ = refl + +_ : extend (step true 8 255 true true false false 0 nothing (1 , just 0) (3 , 1) 0) (3 , 7) (valid (route (1 , just 0) false 128 2 false ((7 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 2))) + ≡ valid (route (1 , just 0) true 255 10 true ((3 , 7) ∷ (7 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 1 255 false true true true 0 nothing (1 , just 0) (5 , 1) 7) (5 , 9) (valid (route (1 , just 0) true 128 13 false ((9 , 3) ∷ (3 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 0) , 0))) + ≡ valid (route (1 , just 0) true 255 14 true ((5 , 9) ∷ (9 , 3) ∷ (3 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 1) , 7)) +_ = refl + +_ : extend (step true 2 255 false true false true 0 nothing (0 , just 3) (2 , 2) 1) (2 , 1) (valid (route (0 , just 2) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 2 0 false false false true 1 nothing (2 , just 2) (2 , 2) 8) (2 , 5) (valid (route (0 , just 2) false 127 0 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 8))) + ≡ valid (route (1 , just 2) false 127 2 false ((2 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 8)) +_ = refl + +_ : extend (step true 8 127 false true false false 0 nothing (0 , just 0) (9 , 1) 0) (9 , 4) (valid (route (0 , just 0) false 0 1 false ((4 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 9))) + ≡ valid (route (0 , just 0) false 127 9 true ((9 , 4) ∷ (4 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 2 122 false false false true 0 nothing (1 , just 1) (4 , 2) 8) (4 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) false 122 2 false ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 8)) +_ = refl + +_ : extend (step true 3 122 false false false false 0 nothing (0 , just 1) (6 , 1) 0) (6 , 4) (valid (route (1 , just 1) true 122 5 false ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 4))) + ≡ invalid +_ = refl + +_ : extend (step true 3 122 false false false true 0 nothing (0 , just 1) (6 , 1) 2) (6 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 4 128 true false false true 0 nothing (0 , just 1) (8 , 1) 5) (8 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) true 128 4 false ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 5)) +_ = refl + +_ : extend (step true 1 127 true true false true 0 nothing (0 , just 0) (5 , 2) 7) (5 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) true 127 1 true ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 1) , 7)) +_ = refl + +_ : extend (step true 11 122 false false false false 0 nothing (1 , just 2) (7 , 2) 0) (7 , 4) (valid (route (1 , just 2) false 255 6 false ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 2))) + ≡ valid (route (1 , just 2) false 255 17 false ((7 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 4 128 false true false true 0 nothing (0 , just 1) (8 , 1) 9) (8 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) false 128 4 true ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 1) , 9)) +_ = refl + +_ : extend (step true 1 0 true false true true 1 nothing (1 , just 2) (8 , 1) 6) (8 , 7) (valid (route (0 , just 2) false 122 17 false ((7 , 2) ∷ (2 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 0))) + ≡ valid (route (1 , just 2) true 122 18 false ((8 , 7) ∷ (7 , 2) ∷ (2 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 6)) +_ = refl + +_ : extend (step true 1 122 false true false false 0 nothing (0 , just 1) (6 , 1) 0) (6 , 9) (valid (route (0 , just 1) false 255 2 false ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 8))) + ≡ valid (route (0 , just 1) false 255 3 true ((6 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 4 0 true false false true 1 nothing (2 , just 2) (7 , 2) 3) (7 , 8) (valid (route (1 , just 2) false 0 6 false ((8 , 6) ∷ (6 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 9))) + ≡ valid (route (2 , just 2) true 0 10 false ((7 , 8) ∷ (8 , 6) ∷ (6 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 3)) +_ = refl + +_ : extend (step true 1 127 false true true true 0 nothing (0 , just 2) (5 , 2) 7) (5 , 4) (valid (route (0 , just 2) false 0 0 false ((4 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 8))) + ≡ valid (route (0 , just 2) false 127 1 true ((5 , 4) ∷ (4 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 1) , 7)) +_ = refl + +_ : extend (step true 4 255 false false false true 0 nothing (0 , just 2) (4 , 1) 9) (4 , 1) (valid (route (0 , just 2) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 2) false 255 4 false ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 0) , 9)) +_ = refl + +_ : extend (step true 4 0 false false false true 0 nothing (0 , just 1) (5 , 2) 6) (5 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) false 0 4 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 6)) +_ = refl + +_ : extend (step true 3 0 false true false true 0 nothing (0 , just 0) (7 , 2) 1) (7 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 0 3 true ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 1) , 1)) +_ = refl + +_ : extend (step true 2 127 false false false true 0 nothing (1 , just 0) (3 , 1) 9) (3 , 8) (valid (route (1 , just 0) false 128 6 false ((8 , 7) ∷ (7 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 0))) + ≡ valid (route (1 , just 0) false 128 8 false ((3 , 8) ∷ (8 , 7) ∷ (7 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 0) , 9)) +_ = refl + +_ : extend (step true 7 255 false true false false 0 nothing (1 , just 0) (6 , 2) 0) (6 , 5) (valid (route (1 , just 0) true 122 8 true ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 1) , 9))) + ≡ valid (route (1 , just 0) true 255 15 true ((6 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 1 128 false false true true 0 nothing (0 , just 1) (8 , 2) 8) (8 , 2) (valid (route (0 , just 1) false 122 3 true ((2 , 9) ∷ (9 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 5))) + ≡ invalid +_ = refl + +_ : extend (step true 4 255 false false false true 0 nothing (0 , just 0) (8 , 2) 7) (8 , 7) (valid (route (0 , just 0) false 255 4 false ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 2))) + ≡ valid (route (0 , just 0) false 255 8 false ((8 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 0) , 7)) +_ = refl + +_ : extend (step true 1 122 false true true true 0 nothing (1 , just 0) (9 , 1) 1) (9 , 2) (valid (route (1 , just 0) false 0 1 true ((2 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 4))) + ≡ invalid +_ = refl + +_ : extend (step true 4 127 false true false true 0 nothing (1 , just 0) (9 , 2) 7) (9 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 127 4 true ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 1) , 7)) +_ = refl + +_ : extend (step true 3 128 false false true true 0 nothing (0 , just 0) (4 , 2) 7) (4 , 2) (valid (route (1 , just 0) true 255 1 true ((2 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 8))) + ≡ invalid +_ = refl + +_ : extend (step true 4 122 false true false true 0 nothing (0 , just 1) (5 , 1) 1) (5 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) false 122 4 true ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 1) , 1)) +_ = refl + +_ : extend (step true 1 255 false true false true 0 nothing (1 , just 1) (4 , 1) 4) (4 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) false 255 1 true ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 1) , 4)) +_ = refl + +_ : extend (step true 5 128 false false false false 0 nothing (0 , just 2) (5 , 2) 0) (5 , 6) (valid (route (0 , just 2) false 122 7 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 7))) + ≡ valid (route (0 , just 2) false 128 12 false ((5 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 7 122 false true false false 0 nothing (1 , just 0) (7 , 2) 0) (7 , 9) (valid (route (0 , just 0) false 122 11 false ((9 , 4) ∷ (4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 3))) + ≡ valid (route (0 , just 0) false 122 18 true ((7 , 9) ∷ (9 , 4) ∷ (4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 4 122 false true false true 0 nothing (0 , just 0) (9 , 1) 2) (9 , 3) (valid (route (0 , just 0) true 122 16 false ((3 , 2) ∷ (2 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 0))) + ≡ valid (route (0 , just 0) true 122 20 true ((9 , 3) ∷ (3 , 2) ∷ (2 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 1) , 2)) +_ = refl + +_ : extend (step true 1 255 true false false true 0 nothing (0 , just 2) (9 , 2) 2) (9 , 1) (valid (route (0 , just 2) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 2) true 255 1 false ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 2)) +_ = refl + +_ : extend (step true 2 255 false false false true 0 nothing (0 , just 0) (7 , 2) 2) (7 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 255 2 false ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 2)) +_ = refl + +_ : extend (step true 3 128 false false false false 0 nothing (1 , just 2) (7 , 2) 0) (7 , 4) (valid (route (1 , just 2) false 122 2 false ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 7))) + ≡ valid (route (1 , just 2) false 128 5 false ((7 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 9 0 false true false false 0 nothing (2 , just 1) (4 , 2) 0) (4 , 5) (valid (route (1 , just 1) false 255 4 true ((5 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 1) , 8))) + ≡ valid (route (1 , just 1) false 255 13 true ((4 , 5) ∷ (5 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 3 0 true false false true 0 nothing (0 , just 2) (9 , 2) 5) (9 , 6) (valid (route (0 , just 2) true 255 7 false ((6 , 8) ∷ (8 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 8))) + ≡ valid (route (0 , just 2) true 255 10 false ((9 , 6) ∷ (6 , 8) ∷ (8 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 5)) +_ = refl + +_ : extend (step true 1 0 false true false true 0 nothing (0 , just 2) (6 , 2) 7) (6 , 5) (valid (route (0 , just 2) false 128 10 true ((5 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 0))) + ≡ valid (route (0 , just 2) false 128 11 true ((6 , 5) ∷ (5 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 7)) +_ = refl + +_ : extend (step true 1 128 true false false true 0 nothing (0 , just 1) (6 , 1) 4) (6 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) true 128 1 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 4)) +_ = refl + +_ : extend (step true 4 255 true true false true 0 nothing (0 , just 2) (9 , 2) 7) (9 , 1) (valid (route (0 , just 2) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 2) true 255 4 true ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 1) , 7)) +_ = refl + +_ : extend (step true 4 0 false false true true 0 nothing (1 , just 1) (8 , 1) 5) (8 , 5) (valid (route (1 , just 1) true 128 6 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 3))) + ≡ valid (route (1 , just 1) true 128 10 false ((8 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 5)) +_ = refl + +_ : extend (step true 2 0 false false false true 0 nothing (0 , just 0) (3 , 2) 1) (3 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 0 2 false ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 1)) +_ = refl + +_ : extend (step true 2 122 true false true true 0 nothing (1 , just 2) (8 , 2) 1) (8 , 4) (valid (route (1 , just 1) true 255 13 true ((4 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 1) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 4 128 true false false false 0 nothing (0 , just 2) (7 , 2) 0) (7 , 8) (valid (route (0 , just 1) false 255 8 false ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 8))) + ≡ invalid +_ = refl + +_ : extend (step true 3 0 false false false false 0 nothing (0 , just 1) (3 , 2) 0) (3 , 7) (valid (route (0 , just 1) true 127 3 false ((7 , 6) ∷ (6 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 7))) + ≡ valid (route (0 , just 1) true 127 6 false ((3 , 7) ∷ (7 , 6) ∷ (6 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 4 128 false true false true 0 nothing (0 , just 1) (7 , 2) 1) (7 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) false 128 4 true ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 1) , 1)) +_ = refl + +_ : extend (step true 1 127 false true false false 0 nothing (2 , just 1) (5 , 1) 0) (5 , 8) (valid (route (1 , just 1) true 127 8 false ((8 , 2) ∷ (2 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 0) , 4))) + ≡ valid (route (1 , just 1) true 127 9 true ((5 , 8) ∷ (8 , 2) ∷ (2 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 10 128 false true false false 0 nothing (1 , just 0) (8 , 1) 0) (8 , 2) (valid (route (1 , just 0) false 128 9 true ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 3))) + ≡ valid (route (1 , just 0) false 128 19 true ((8 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 12 127 false false false false 0 nothing (1 , just 1) (3 , 1) 0) (3 , 2) (valid (route (1 , just 1) false 255 5 true ((2 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 2))) + ≡ valid (route (1 , just 1) false 255 17 true ((3 , 2) ∷ (2 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 1 0 false true true true 0 nothing (0 , just 0) (5 , 1) 2) (5 , 6) (valid (route (0 , just 0) false 0 5 false ((6 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 6))) + ≡ valid (route (0 , just 0) false 0 6 true ((5 , 6) ∷ (6 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 1) , 2)) +_ = refl + +_ : extend (step true 4 0 false false false true 0 nothing (1 , just 0) (6 , 1) 7) (6 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 0 4 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 7)) +_ = refl + +_ : extend (step true 1 0 false true false true 0 nothing (0 , just 0) (6 , 1) 2) (6 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 0 1 true ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 1) , 2)) +_ = refl + +_ : extend (step true 2 128 true false false true 1 nothing (2 , just 2) (5 , 2) 6) (5 , 9) (valid (route (1 , just 2) false 127 5 true ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 1) , 1))) + ≡ valid (route (2 , just 2) true 128 7 true ((5 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 1) , 6)) +_ = refl + +_ : extend (step true 4 0 false true false false 0 nothing (0 , just 2) (4 , 1) 0) (4 , 9) (valid (route (0 , just 2) false 127 3 true ((9 , 2) ∷ (2 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 1) , 1))) + ≡ valid (route (0 , just 2) false 127 7 true ((4 , 9) ∷ (9 , 2) ∷ (2 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 2 127 false true false true 0 nothing (1 , just 2) (4 , 2) 2) (4 , 6) (valid (route (1 , just 2) false 255 11 true ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 3))) + ≡ valid (route (1 , just 2) false 255 13 true ((4 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 1) , 2)) +_ = refl + +_ : extend (step true 3 122 true true false true 1 nothing (2 , just 2) (2 , 2) 3) (2 , 9) (valid (route (1 , just 2) true 255 12 false ((9 , 7) ∷ (7 , 25) ∷ (25 , 12) ∷ (12 , 20) ∷ (20 , 43) ∷ (43 , 14) ∷ (14 , 41) ∷ (41 , 4) ∷ (4 , 31) ∷ (31 , 55) ∷ (55 , 21) ∷ (21 , 34) ∷ (34 , 36) ∷ (36 , 16) ∷ (16 , 30) ∷ (30 , 23) ∷ (23 , 27) ∷ (27 , 47) ∷ (47 , 39) ∷ (39 , 42) ∷ (42 , 46) ∷ (46 , 28) ∷ (28 , 53) ∷ (53 , 38) ∷ (38 , 48) ∷ (48 , 8) ∷ (8 , 6) ∷ (6 , 33) ∷ (33 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 0))) + ≡ valid (route (2 , just 2) true 255 15 true ((2 , 9) ∷ (9 , 7) ∷ (7 , 25) ∷ (25 , 12) ∷ (12 , 20) ∷ (20 , 43) ∷ (43 , 14) ∷ (14 , 41) ∷ (41 , 4) ∷ (4 , 31) ∷ (31 , 55) ∷ (55 , 21) ∷ (21 , 34) ∷ (34 , 36) ∷ (36 , 16) ∷ (16 , 30) ∷ (30 , 23) ∷ (23 , 27) ∷ (27 , 47) ∷ (47 , 39) ∷ (39 , 42) ∷ (42 , 46) ∷ (46 , 28) ∷ (28 , 53) ∷ (53 , 38) ∷ (38 , 48) ∷ (48 , 8) ∷ (8 , 6) ∷ (6 , 33) ∷ (33 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 3)) +_ = refl + +_ : extend (step true 4 127 true false false true 1 nothing (1 , just 1) (6 , 1) 2) (6 , 8) (valid (route (0 , just 1) false 255 3 false ((8 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 1))) + ≡ valid (route (1 , just 1) true 255 7 false ((6 , 8) ∷ (8 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 2)) +_ = refl + +_ : extend (step true 4 122 true false false false 0 nothing (1 , just 2) (5 , 2) 0) (5 , 4) (valid (route (1 , just 2) false 128 7 true ((4 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 1) , 6))) + ≡ valid (route (1 , just 2) true 128 11 true ((5 , 4) ∷ (4 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 3 127 false true false false 0 nothing (1 , just 1) (2 , 2) 0) (2 , 9) (valid (route (0 , just 1) false 122 11 false ((9 , 8) ∷ (8 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 9))) + ≡ valid (route (0 , just 1) false 127 14 true ((2 , 9) ∷ (9 , 8) ∷ (8 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 1 255 false false true true 1 nothing (0 , just 1) (8 , 1) 2) (8 , 7) (valid (route (0 , just 2) false 255 8 true ((7 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 1) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 11 122 false true false false 0 nothing (0 , just 0) (3 , 2) 0) (3 , 7) (valid (route (0 , just 0) false 0 8 false ((7 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 8))) + ≡ valid (route (0 , just 0) false 122 19 true ((3 , 7) ∷ (7 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 1 0 false true true true 1 nothing (2 , just 1) (6 , 2) 8) (6 , 9) (valid (route (1 , just 1) false 255 11 false ((9 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 5))) + ≡ valid (route (2 , just 1) false 255 12 true ((6 , 9) ∷ (9 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 8)) +_ = refl + +_ : extend (step true 3 255 false false false true 0 nothing (0 , just 0) (9 , 2) 2) (9 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 255 3 false ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 2)) +_ = refl + +_ : extend (step true 4 128 true true true true 1 nothing (2 , just 1) (7 , 2) 9) (7 , 6) (valid (route (0 , just 1) false 122 3 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 6))) + ≡ valid (route (1 , just 1) true 128 7 true ((7 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 1) , 9)) +_ = refl + +_ : extend (step true 3 127 false true false true 0 nothing (0 , just 1) (2 , 2) 3) (2 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 6 128 false false false false 0 nothing (0 , just 2) (2 , 2) 0) (2 , 6) (valid (route (0 , just 2) false 128 7 false ((6 , 8) ∷ (8 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 1))) + ≡ valid (route (0 , just 2) false 128 13 false ((2 , 6) ∷ (6 , 8) ∷ (8 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 9 128 false false false false 0 nothing (1 , just 0) (7 , 2) 0) (7 , 2) (valid (route (1 , just 0) false 255 3 false ((2 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 8))) + ≡ valid (route (1 , just 0) false 255 12 false ((7 , 2) ∷ (2 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 5 127 false false false false 0 nothing (2 , just 0) (7 , 2) 0) (7 , 2) (valid (route (1 , just 0) false 122 2 true ((2 , 4) ∷ (4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 6))) + ≡ valid (route (1 , just 0) false 127 7 true ((7 , 2) ∷ (2 , 4) ∷ (4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 3 122 false false true true 1 nothing (1 , just 2) (2 , 1) 2) (2 , 3) (valid (route (0 , just 2) false 122 10 true ((3 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 9))) + ≡ invalid +_ = refl + +_ : extend (step true 3 128 false false false true 0 nothing (0 , just 1) (4 , 1) 1) (4 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 7 127 true false false false 0 nothing (0 , just 2) (2 , 2) 0) (2 , 3) (valid (route (0 , just 2) false 255 11 false ((3 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 5))) + ≡ valid (route (0 , just 2) true 255 18 false ((2 , 3) ∷ (3 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 3 255 true false false true 1 nothing (2 , just 2) (3 , 2) 2) (3 , 8) (valid (route (1 , just 2) false 255 3 true ((8 , 2) ∷ (2 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 1) , 5))) + ≡ valid (route (2 , just 2) true 255 6 true ((3 , 8) ∷ (8 , 2) ∷ (2 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 1) , 2)) +_ = refl + +_ : extend (step true 3 122 false false false true 1 nothing (0 , just 1) (2 , 1) 5) (2 , 5) (valid (route (0 , just 1) false 255 2 false ((5 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 1))) + ≡ invalid +_ = refl + +_ : extend (step true 6 255 true false false false 0 nothing (0 , just 0) (4 , 2) 0) (4 , 9) (valid (route (0 , just 0) false 0 9 false ((9 , 6) ∷ (6 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 6))) + ≡ valid (route (0 , just 0) true 255 15 false ((4 , 9) ∷ (9 , 6) ∷ (6 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 2 128 false true false true 0 nothing (2 , just 0) (4 , 1) 7) (4 , 6) (valid (route (1 , just 0) true 128 3 false ((6 , 23) ∷ (23 , 41) ∷ (41 , 2) ∷ (2 , 42) ∷ (42 , 31) ∷ (31 , 20) ∷ (20 , 19) ∷ (19 , 33) ∷ (33 , 39) ∷ (39 , 59) ∷ (59 , 44) ∷ (44 , 14) ∷ (14 , 28) ∷ (28 , 18) ∷ (18 , 5) ∷ (5 , 35) ∷ (35 , 24) ∷ (24 , 30) ∷ (30 , 15) ∷ (15 , 37) ∷ (37 , 50) ∷ (50 , 11) ∷ (11 , 22) ∷ (22 , 40) ∷ (40 , 55) ∷ (55 , 57) ∷ (57 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 8))) + ≡ valid (route (1 , just 0) true 128 5 true ((4 , 6) ∷ (6 , 23) ∷ (23 , 41) ∷ (41 , 2) ∷ (2 , 42) ∷ (42 , 31) ∷ (31 , 20) ∷ (20 , 19) ∷ (19 , 33) ∷ (33 , 39) ∷ (39 , 59) ∷ (59 , 44) ∷ (44 , 14) ∷ (14 , 28) ∷ (28 , 18) ∷ (18 , 5) ∷ (5 , 35) ∷ (35 , 24) ∷ (24 , 30) ∷ (30 , 15) ∷ (15 , 37) ∷ (37 , 50) ∷ (50 , 11) ∷ (11 , 22) ∷ (22 , 40) ∷ (40 , 55) ∷ (55 , 57) ∷ (57 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 1) , 7)) +_ = refl + +_ : extend (step true 1 255 true false false true 1 nothing (0 , just 1) (5 , 2) 7) (5 , 2) (valid (route (1 , just 0) false 122 2 true ((2 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 5))) + ≡ invalid +_ = refl + +_ : extend (step true 7 0 true false false false 0 nothing (0 , just 0) (2 , 1) 0) (2 , 3) (valid (route (0 , just 0) false 0 2 true ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 1) , 7))) + ≡ valid (route (0 , just 0) true 0 9 true ((2 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 2 128 false false false true 0 nothing (0 , just 1) (3 , 1) 4) (3 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) false 128 2 false ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 0) , 4)) +_ = refl + +_ : extend (step true 8 128 false true false false 0 nothing (0 , just 2) (7 , 1) 0) (7 , 3) (valid (route (1 , just 2) false 128 7 true ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 1) , 2))) + ≡ invalid +_ = refl + +_ : extend (step true 2 128 false false false true 1 nothing (1 , just 2) (7 , 2) 8) (7 , 4) (valid (route (0 , just 2) false 128 15 true ((4 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 0))) + ≡ valid (route (1 , just 2) false 128 17 true ((7 , 4) ∷ (4 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 1) , 8)) +_ = refl + +_ : extend (step true 3 128 false false false true 0 nothing (0 , just 2) (4 , 2) 9) (4 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 1 122 false false false true 0 nothing (0 , just 2) (6 , 2) 6) (6 , 9) (valid (route (0 , just 2) false 255 6 false ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 7))) + ≡ valid (route (0 , just 2) false 255 7 false ((6 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 6)) +_ = refl + +_ : extend (step true 1 128 false false false true 0 nothing (1 , just 2) (9 , 1) 6) (9 , 1) (valid (route (0 , just 2) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 2) false 128 1 false ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 6)) +_ = refl + +_ : extend (step true 12 128 false false false false 0 nothing (1 , just 1) (5 , 2) 0) (5 , 6) (valid (route (0 , just 1) false 122 4 true ((6 , 4) ∷ (4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 8))) + ≡ valid (route (0 , just 1) false 128 16 true ((5 , 6) ∷ (6 , 4) ∷ (4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 4 127 false false false true 1 nothing (0 , just 1) (8 , 1) 6) (8 , 6) (valid (route (0 , just 1) false 0 7 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 9))) + ≡ invalid +_ = refl + +_ : extend (step true 11 0 false true false false 0 nothing (0 , just 2) (9 , 2) 0) (9 , 4) (valid (route (0 , just 2) false 128 5 false ((4 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 5))) + ≡ valid (route (0 , just 2) false 128 16 true ((9 , 4) ∷ (4 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 4 128 false false false true 0 nothing (1 , just 0) (2 , 2) 6) (2 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 128 4 false ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 6)) +_ = refl + +_ : extend (step true 2 122 false false false false 0 nothing (0 , just 0) (4 , 1) 0) (4 , 9) (valid (route (0 , just 0) true 122 11 true ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 1) , 4))) + ≡ valid (route (0 , just 0) true 122 13 true ((4 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 2 127 false false true true 0 nothing (1 , just 1) (3 , 2) 1) (3 , 7) (valid (route (1 , just 2) true 128 22 true ((7 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 1) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 8 255 false true false false 0 nothing (1 , just 0) (4 , 2) 0) (4 , 3) (valid (route (1 , just 0) false 128 11 false ((3 , 8) ∷ (8 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 5))) + ≡ valid (route (1 , just 0) false 255 19 true ((4 , 3) ∷ (3 , 8) ∷ (8 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 3 122 false false false true 0 nothing (0 , just 3) (5 , 2) 6) (5 , 4) (valid (route (0 , just 2) false 255 7 false ((4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 0) , 3))) + ≡ invalid +_ = refl + +_ : extend (step true 4 127 false false false false 0 nothing (1 , just 1) (8 , 2) 0) (8 , 7) (valid (route (1 , just 1) false 122 8 false ((7 , 6) ∷ (6 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 6))) + ≡ valid (route (1 , just 1) false 127 12 false ((8 , 7) ∷ (7 , 6) ∷ (6 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 3 255 false true false true 0 nothing (1 , just 1) (3 , 1) 2) (3 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) false 255 3 true ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 2)) +_ = refl + +_ : extend (step true 4 128 true true false true 1 nothing (3 , just 2) (7 , 2) 7) (7 , 3) (valid (route (1 , just 2) false 127 4 false ((3 , 4) ∷ (4 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 0) , 8))) + ≡ valid (route (2 , just 2) true 128 8 true ((7 , 3) ∷ (3 , 4) ∷ (4 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 1) , 7)) +_ = refl + +_ : extend (step true 4 128 false false false true 0 nothing (0 , just 1) (6 , 2) 6) (6 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 3 128 false false false false 0 nothing (1 , just 1) (5 , 1) 0) (5 , 6) (valid (route (1 , just 1) true 255 9 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 4))) + ≡ valid (route (1 , just 1) true 255 12 false ((5 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 7 255 false false false false 0 nothing (0 , just 1) (9 , 2) 0) (9 , 3) (valid (route (0 , just 1) true 0 4 false ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 6))) + ≡ valid (route (0 , just 1) true 255 11 false ((9 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 4 255 false true false true 0 nothing (0 , just 0) (4 , 1) 4) (4 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 255 4 true ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 1) , 4)) +_ = refl + +_ : extend (step true 7 127 false false false false 0 nothing (0 , just 0) (4 , 1) 0) (4 , 2) (valid (route (0 , just 0) false 255 6 true ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 5))) + ≡ valid (route (0 , just 0) false 255 13 true ((4 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 5 128 false false false false 0 nothing (0 , just 2) (7 , 2) 0) (7 , 8) (valid (route (0 , just 2) false 128 6 true ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 1) , 3))) + ≡ valid (route (0 , just 2) false 128 11 true ((7 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 3 127 true false true true 1 nothing (0 , just 2) (9 , 1) 5) (9 , 4) (valid (route (0 , just 0) false 255 23 true ((4 , 2) ∷ (2 , 5) ∷ (5 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 2 127 false false false true 0 nothing (0 , just 0) (2 , 1) 4) (2 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 127 2 false ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 4)) +_ = refl + +_ : extend (step true 8 0 false true false false 0 nothing (0 , just 3) (3 , 1) 0) (3 , 7) (valid (route (0 , just 2) false 128 7 false ((7 , 8) ∷ (8 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 8))) + ≡ invalid +_ = refl + +_ : extend (step true 3 255 false false false true 0 nothing (0 , just 2) (3 , 2) 5) (3 , 1) (valid (route (0 , just 2) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 2) false 255 3 false ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 5)) +_ = refl + +_ : extend (step true 2 255 true true false false 0 nothing (1 , just 2) (9 , 1) 0) (9 , 5) (valid (route (1 , just 2) false 255 9 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 1))) + ≡ valid (route (1 , just 2) true 255 11 true ((9 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 1 122 false false true true 1 nothing (2 , just 0) (9 , 1) 6) (9 , 5) (valid (route (1 , just 0) true 255 13 false ((5 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 0))) + ≡ valid (route (2 , just 0) true 255 14 false ((9 , 5) ∷ (5 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 6)) +_ = refl + +_ : extend (step true 3 122 true false false true 0 nothing (0 , just 0) (6 , 2) 4) (6 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) true 122 3 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 4)) +_ = refl + +_ : extend (step true 1 128 true false false true 0 nothing (0 , just 2) (9 , 1) 1) (9 , 1) (valid (route (0 , just 2) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 2) true 128 1 false ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 1)) +_ = refl + +_ : extend (step true 11 0 true false false false 0 nothing (1 , just 2) (8 , 2) 0) (8 , 9) (valid (route (1 , just 2) false 128 8 false ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 3))) + ≡ valid (route (1 , just 2) true 128 19 false ((8 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 8 127 false true false false 0 nothing (1 , just 2) (4 , 2) 0) (4 , 2) (valid (route (1 , just 2) false 127 3 true ((2 , 52) ∷ (52 , 31) ∷ (31 , 21) ∷ (21 , 53) ∷ (53 , 9) ∷ (9 , 30) ∷ (30 , 33) ∷ (33 , 40) ∷ (40 , 26) ∷ (26 , 8) ∷ (8 , 7) ∷ (7 , 61) ∷ (61 , 54) ∷ (54 , 3) ∷ (3 , 57) ∷ (57 , 25) ∷ (25 , 41) ∷ (41 , 43) ∷ (43 , 51) ∷ (51 , 36) ∷ (36 , 11) ∷ (11 , 24) ∷ (24 , 34) ∷ (34 , 29) ∷ (29 , 39) ∷ (39 , 18) ∷ (18 , 19) ∷ (19 , 27) ∷ (27 , 45) ∷ (45 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 7))) + ≡ valid (route (1 , just 2) false 127 11 true ((4 , 2) ∷ (2 , 52) ∷ (52 , 31) ∷ (31 , 21) ∷ (21 , 53) ∷ (53 , 9) ∷ (9 , 30) ∷ (30 , 33) ∷ (33 , 40) ∷ (40 , 26) ∷ (26 , 8) ∷ (8 , 7) ∷ (7 , 61) ∷ (61 , 54) ∷ (54 , 3) ∷ (3 , 57) ∷ (57 , 25) ∷ (25 , 41) ∷ (41 , 43) ∷ (43 , 51) ∷ (51 , 36) ∷ (36 , 11) ∷ (11 , 24) ∷ (24 , 34) ∷ (34 , 29) ∷ (29 , 39) ∷ (39 , 18) ∷ (18 , 19) ∷ (19 , 27) ∷ (27 , 45) ∷ (45 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 12 0 false false false false 0 nothing (0 , just 2) (8 , 2) 0) (8 , 7) (valid (route (0 , just 1) true 127 7 true ((7 , 5) ∷ (5 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 1) , 3))) + ≡ invalid +_ = refl + +_ : extend (step true 4 128 false false false true 1 nothing (1 , just 2) (2 , 1) 1) (2 , 3) (valid (route (0 , just 2) true 0 5 true ((3 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 0) , 0))) + ≡ valid (route (1 , just 2) true 128 9 true ((2 , 3) ∷ (3 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 1)) +_ = refl + +_ : extend (step true 7 127 false true false false 0 nothing (0 , just 2) (3 , 1) 0) (3 , 7) (valid (route (0 , just 2) false 255 4 false ((7 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 4))) + ≡ valid (route (0 , just 2) false 255 11 true ((3 , 7) ∷ (7 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 2 127 true false false true 0 nothing (0 , just 3) (9 , 1) 1) (9 , 1) (valid (route (0 , just 2) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 1 127 false false false true 0 nothing (1 , just 1) (5 , 1) 2) (5 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) false 127 1 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 2)) +_ = refl + +_ : extend (step true 1 0 false true false true 0 nothing (0 , just 0) (3 , 2) 8) (3 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 0 1 true ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 1) , 8)) +_ = refl + +_ : extend (step true 4 127 false false true true 0 nothing (1 , just 1) (9 , 2) 8) (9 , 6) (valid (route (1 , just 1) false 0 4 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 3))) + ≡ valid (route (1 , just 1) false 127 8 false ((9 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 8)) +_ = refl + +_ : extend (step true 1 255 false false true true 1 nothing (1 , just 0) (9 , 2) 9) (9 , 3) (valid (route (0 , just 0) false 0 2 false ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 0) , 7))) + ≡ valid (route (1 , just 0) false 255 3 false ((9 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 9)) +_ = refl + +_ : extend (step true 6 0 false false false false 0 nothing (0 , just 1) (8 , 1) 0) (8 , 7) (valid (route (1 , just 1) false 127 11 false ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 6))) + ≡ invalid +_ = refl + +_ : extend (step true 10 127 false true false false 0 nothing (1 , just 2) (7 , 2) 0) (7 , 5) (valid (route (1 , just 2) false 255 5 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 1))) + ≡ valid (route (1 , just 2) false 255 15 true ((7 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 2 255 false false false true 0 nothing (0 , just 0) (5 , 2) 1) (5 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 255 2 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 1)) +_ = refl + +_ : extend (step true 1 122 false true false true 0 nothing (0 , just 0) (8 , 1) 9) (8 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 122 1 true ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 1) , 9)) +_ = refl + +_ : extend (step true 2 128 false false false true 0 nothing (0 , just 2) (6 , 1) 8) (6 , 3) (valid (route (0 , just 2) false 128 18 false ((3 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 0) , 0))) + ≡ valid (route (0 , just 2) false 128 20 false ((6 , 3) ∷ (3 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 8)) +_ = refl + +_ : extend (step true 7 0 false false false false 0 nothing (1 , just 0) (5 , 1) 0) (5 , 7) (valid (route (0 , just 0) false 255 0 false ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 3))) + ≡ valid (route (0 , just 0) false 255 7 false ((5 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 2 255 false false false true 0 nothing (1 , just 0) (4 , 2) 3) (4 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 255 2 false ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 3)) +_ = refl + +_ : extend (step true 11 255 false false false false 0 nothing (0 , just 0) (3 , 2) 0) (3 , 8) (valid (route (0 , just 0) false 255 3 false ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 7))) + ≡ valid (route (0 , just 0) false 255 14 false ((3 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 3 0 false false true true 1 nothing (0 , just 0) (8 , 2) 2) (8 , 9) (valid (route (0 , just 0) false 127 7 false ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 3))) + ≡ invalid +_ = refl + +_ : extend (step true 1 122 false false false true 1 nothing (1 , just 0) (4 , 2) 5) (4 , 9) (valid (route (0 , just 0) false 128 5 true ((9 , 8) ∷ (8 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 1) , 2))) + ≡ valid (route (1 , just 0) false 128 6 true ((4 , 9) ∷ (9 , 8) ∷ (8 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 1) , 5)) +_ = refl + +_ : extend (step true 12 0 true true false false 0 nothing (1 , just 0) (3 , 1) 0) (3 , 4) (valid (route (1 , just 0) true 128 5 false ((4 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 4))) + ≡ valid (route (1 , just 0) true 128 17 true ((3 , 4) ∷ (4 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 2 0 true false false true 0 nothing (0 , just 0) (2 , 1) 3) (2 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) true 0 2 false ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 3)) +_ = refl + +_ : extend (step true 1 127 false false false true 0 nothing (0 , just 0) (6 , 1) 1) (6 , 5) (valid (route (1 , just 0) true 128 2 false ((5 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 0) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 6 0 false true false false 0 nothing (1 , just 2) (7 , 2) 0) (7 , 2) (valid (route (1 , just 2) true 122 1 true ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 3))) + ≡ valid (route (1 , just 2) true 122 7 true ((7 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 11 255 false true false false 0 nothing (1 , just 0) (2 , 2) 0) (2 , 6) (valid (route (1 , just 0) false 255 6 true ((6 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 6))) + ≡ valid (route (1 , just 0) false 255 17 true ((2 , 6) ∷ (6 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 3 122 false true false false 0 nothing (0 , just 1) (5 , 1) 0) (5 , 2) (valid (route (0 , just 0) false 122 11 false ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 7))) + ≡ invalid +_ = refl + +_ : extend (step true 5 122 false false false false 0 nothing (0 , just 0) (3 , 1) 0) (3 , 4) (valid (route (0 , just 0) false 122 5 true ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 1) , 5))) + ≡ valid (route (0 , just 0) false 122 10 true ((3 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 2 0 false false false false 0 nothing (0 , just 2) (2 , 1) 0) (2 , 9) (valid (route (0 , just 1) false 122 7 false ((9 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 1))) + ≡ invalid +_ = refl + +_ : extend (step true 9 0 false false false false 0 nothing (0 , just 0) (8 , 1) 0) (8 , 7) (valid (route (0 , just 0) false 255 4 false ((7 , 53) ∷ (53 , 34) ∷ (34 , 26) ∷ (26 , 46) ∷ (46 , 44) ∷ (44 , 5) ∷ (5 , 35) ∷ (35 , 60) ∷ (60 , 48) ∷ (48 , 57) ∷ (57 , 43) ∷ (43 , 16) ∷ (16 , 52) ∷ (52 , 29) ∷ (29 , 55) ∷ (55 , 27) ∷ (27 , 56) ∷ (56 , 24) ∷ (24 , 14) ∷ (14 , 59) ∷ (59 , 25) ∷ (25 , 17) ∷ (17 , 9) ∷ (9 , 40) ∷ (40 , 31) ∷ (31 , 61) ∷ (61 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 6))) + ≡ valid (route (0 , just 0) false 255 13 false ((8 , 7) ∷ (7 , 53) ∷ (53 , 34) ∷ (34 , 26) ∷ (26 , 46) ∷ (46 , 44) ∷ (44 , 5) ∷ (5 , 35) ∷ (35 , 60) ∷ (60 , 48) ∷ (48 , 57) ∷ (57 , 43) ∷ (43 , 16) ∷ (16 , 52) ∷ (52 , 29) ∷ (29 , 55) ∷ (55 , 27) ∷ (27 , 56) ∷ (56 , 24) ∷ (24 , 14) ∷ (14 , 59) ∷ (59 , 25) ∷ (25 , 17) ∷ (17 , 9) ∷ (9 , 40) ∷ (40 , 31) ∷ (31 , 61) ∷ (61 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 4 0 false true true true 1 nothing (2 , just 1) (8 , 1) 1) (8 , 5) (valid (route (1 , just 1) false 122 0 false ((5 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 1))) + ⊕ extend (step true 1 128 false true false true 0 nothing (2 , just 1) (8 , 1) 6) (8 , 7) (valid (route (1 , just 0) false 255 16 false ((7 , 2) ∷ (2 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 0))) + ≡ valid (route (1 , just 0) false 255 17 true ((8 , 7) ∷ (7 , 2) ∷ (2 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 1) , 6)) +_ = refl + +_ : extend (step true 2 127 false true false true 0 nothing (2 , just 1) (8 , 1) 2) (8 , 2) (valid (route (1 , just 1) false 127 12 false ((2 , 4) ∷ (4 , 3) ∷ (3 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 0))) + ⊕ extend (step true 2 127 false true false true 0 nothing (2 , just 1) (8 , 1) 3) (8 , 7) (valid (route (1 , just 1) false 127 12 false ((7 , 4) ∷ (4 , 3) ∷ (3 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 0))) + ≡ valid (route (1 , just 1) false 127 14 true ((8 , 2) ∷ (2 , 4) ∷ (4 , 3) ∷ (3 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 1) , 2)) +_ = refl + +_ : extend (step true 4 0 false false false true 0 nothing (0 , just 1) (9 , 2) 1) (9 , 3) (valid (route (0 , just 1) true 255 17 false ((3 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 0))) + ⊕ extend (step true 8 122 false true false false 0 nothing (0 , just 1) (9 , 2) 0) (9 , 2) (valid (route (0 , just 2) false 122 3 false ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 5))) + ≡ valid (route (0 , just 2) false 122 11 true ((9 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 4 0 false false false true 0 nothing (0 , just 0) (5 , 2) 4) (5 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ⊕ extend (step true 6 255 false false false false 0 nothing (0 , just 0) (5 , 2) 0) (5 , 8) (valid (route (0 , just 2) false 0 3 true ((8 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 1) , 4))) + ≡ valid (route (0 , just 2) false 255 9 true ((5 , 8) ∷ (8 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 11 0 false true false false 0 nothing (1 , just 2) (9 , 2) 0) (9 , 8) (valid (route (1 , just 2) false 127 4 false ((8 , 4) ∷ (4 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 7))) + ⊕ extend (step true 4 127 false true false false 0 nothing (1 , just 2) (9 , 2) 0) (9 , 6) (valid (route (1 , just 2) false 122 7 true ((6 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 1) , 8))) + ≡ valid (route (1 , just 2) false 127 11 true ((9 , 6) ∷ (6 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 4 122 false false false false 0 nothing (0 , just 2) (4 , 2) 0) (4 , 2) (valid (route (0 , just 2) true 0 10 false ((2 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 5))) + ⊕ extend (step true 4 122 false true false false 0 nothing (0 , just 2) (4 , 2) 0) (4 , 6) (valid (route (0 , just 2) true 0 10 false ((6 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 5))) + ≡ valid (route (0 , just 2) true 122 14 false ((4 , 2) ∷ (2 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 3 128 true true true true 1 nothing (0 , just 1) (7 , 2) 3) (7 , 3) (valid (route (0 , just 2) false 122 12 true ((3 , 2) ∷ (2 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 0))) + ⊕ extend (step true 3 128 true true true true 1 nothing (0 , just 1) (7 , 2) 4) (7 , 6) (valid (route (0 , just 2) false 122 12 true ((6 , 2) ∷ (2 , 8) ∷ (8 , 172) ∷ (172 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 4 127 false false false false 0 nothing (1 , just 1) (2 , 2) 0) (2 , 7) (valid (route (1 , just 1) false 127 0 false ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 8))) + ⊕ extend (step true 4 127 false false false false 0 nothing (1 , just 1) (2 , 2) 0) (2 , 6) (valid (route (1 , just 1) false 127 0 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 8))) + ≡ valid (route (1 , just 1) false 127 4 false ((2 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 3 0 false false false true 0 nothing (1 , just 1) (8 , 2) 5) (8 , 4) (valid (route (1 , just 1) false 255 9 true ((4 , 6) ∷ (6 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 0))) + ⊕ extend (step true 3 0 false false false true 0 nothing (1 , just 1) (8 , 2) 6) (8 , 7) (valid (route (1 , just 1) false 255 9 true ((7 , 6) ∷ (6 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 0))) + ≡ valid (route (1 , just 1) false 255 12 true ((8 , 4) ∷ (4 , 6) ∷ (6 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 1) , 5)) +_ = refl + +_ : extend (step true 4 255 true false false false 0 nothing (0 , just 3) (9 , 2) 0) (9 , 7) (valid (route (0 , just 2) false 122 10 false ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 3))) + ⊕ extend (step true 3 127 false true false true 1 nothing (0 , just 3) (9 , 2) 6) (9 , 6) (valid (route (1 , just 1) false 122 0 true ((6 , 4) ∷ (4 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 3))) + ≡ invalid +_ = refl + +_ : extend (step true 5 127 false false false false 0 nothing (0 , just 2) (5 , 1) 0) (5 , 6) (valid (route (0 , just 1) false 128 8 true ((6 , 8) ∷ (8 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 1) , 7))) + ⊕ extend (step true 1 255 false true false false 0 nothing (0 , just 2) (5 , 1) 0) (5 , 6) (valid (route (1 , just 2) false 0 9 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 8))) + ≡ invalid +_ = refl + +_ : extend (step true 2 0 false false false true 1 nothing (2 , just 0) (2 , 2) 6) (2 , 6) (valid (route (0 , just 0) true 128 11 false ((6 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 1))) + ⊕ extend (step true 4 0 false true false false 0 nothing (2 , just 0) (2 , 2) 0) (2 , 9) (valid (route (0 , just 0) false 0 8 false ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 6))) + ≡ valid (route (0 , just 0) false 0 12 true ((2 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 5 122 true true false false 0 nothing (0 , just 1) (7 , 1) 0) (7 , 3) (valid (route (1 , just 1) false 122 11 true ((3 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 6))) + ⊕ extend (step true 5 122 true true false false 0 nothing (0 , just 1) (7 , 1) 0) (7 , 4) (valid (route (1 , just 1) false 122 11 true ((4 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 1) , 6))) + ≡ invalid +_ = refl + +_ : extend (step true 1 255 true false false true 0 nothing (1 , just 0) (5 , 2) 5) (5 , 7) (valid (route (0 , just 0) false 122 4 false ((7 , 9) ∷ (9 , 60) ∷ (60 , 18) ∷ (18 , 35) ∷ (35 , 23) ∷ (23 , 25) ∷ (25 , 47) ∷ (47 , 27) ∷ (27 , 8) ∷ (8 , 34) ∷ (34 , 33) ∷ (33 , 11) ∷ (11 , 10) ∷ (10 , 26) ∷ (26 , 48) ∷ (48 , 36) ∷ (36 , 44) ∷ (44 , 56) ∷ (56 , 14) ∷ (14 , 38) ∷ (38 , 37) ∷ (37 , 22) ∷ (22 , 53) ∷ (53 , 46) ∷ (46 , 32) ∷ (32 , 24) ∷ (24 , 21) ∷ (21 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 5))) + ⊕ extend (step true 1 255 true false false true 0 nothing (1 , just 0) (5 , 2) 6) (5 , 2) (valid (route (0 , just 0) false 122 4 false ((2 , 9) ∷ (9 , 60) ∷ (60 , 18) ∷ (18 , 35) ∷ (35 , 23) ∷ (23 , 25) ∷ (25 , 47) ∷ (47 , 27) ∷ (27 , 8) ∷ (8 , 34) ∷ (34 , 33) ∷ (33 , 11) ∷ (11 , 10) ∷ (10 , 26) ∷ (26 , 48) ∷ (48 , 36) ∷ (36 , 44) ∷ (44 , 56) ∷ (56 , 14) ∷ (14 , 38) ∷ (38 , 37) ∷ (37 , 22) ∷ (22 , 53) ∷ (53 , 46) ∷ (46 , 32) ∷ (32 , 24) ∷ (24 , 21) ∷ (21 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 5))) + ≡ valid (route (0 , just 0) true 255 5 false ((5 , 7) ∷ (7 , 9) ∷ (9 , 60) ∷ (60 , 18) ∷ (18 , 35) ∷ (35 , 23) ∷ (23 , 25) ∷ (25 , 47) ∷ (47 , 27) ∷ (27 , 8) ∷ (8 , 34) ∷ (34 , 33) ∷ (33 , 11) ∷ (11 , 10) ∷ (10 , 26) ∷ (26 , 48) ∷ (48 , 36) ∷ (36 , 44) ∷ (44 , 56) ∷ (56 , 14) ∷ (14 , 38) ∷ (38 , 37) ∷ (37 , 22) ∷ (22 , 53) ∷ (53 , 46) ∷ (46 , 32) ∷ (32 , 24) ∷ (24 , 21) ∷ (21 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 5)) +_ = refl + +_ : extend (step true 1 0 true false false true 0 nothing (1 , just 1) (3 , 1) 8) (3 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ⊕ extend (step true 2 0 false false false true 1 nothing (1 , just 1) (3 , 1) 6) (3 , 2) (valid (route (0 , just 2) false 255 6 false ((2 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 3))) + ≡ valid (route (0 , just 1) true 0 1 false ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 0) , 8)) +_ = refl + +_ : extend (step true 1 0 true true false true 0 nothing (0 , just 2) (6 , 2) 8) (6 , 3) (valid (route (0 , just 2) false 127 14 false ((3 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 0))) + ⊕ extend (step true 1 0 true true false true 0 nothing (0 , just 2) (6 , 2) 9) (6 , 4) (valid (route (0 , just 2) false 127 14 false ((4 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 0))) + ≡ valid (route (0 , just 2) true 127 15 true ((6 , 3) ∷ (3 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 8)) +_ = refl + +_ : extend (step true 7 128 false true false false 0 nothing (2 , just 0) (5 , 2) 0) (5 , 7) (valid (route (1 , just 0) false 122 3 false ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 9))) + ⊕ extend (step true 7 128 false true false false 0 nothing (2 , just 0) (5 , 2) 0) (5 , 6) (valid (route (1 , just 0) false 122 3 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 9))) + ≡ valid (route (1 , just 0) false 128 10 true ((5 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 2 0 false true false false 0 nothing (2 , just 2) (2 , 2) 0) (2 , 9) (valid (route (1 , just 2) false 0 8 false ((9 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 3))) + ⊕ extend (step true 2 0 false true false false 0 nothing (2 , just 2) (2 , 2) 0) (2 , 6) (valid (route (1 , just 2) false 0 8 false ((6 , 7) ∷ (7 , 136) ∷ (136 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 3))) + ≡ valid (route (1 , just 2) false 0 10 true ((2 , 9) ∷ (9 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 1 0 false false true true 1 nothing (0 , just 2) (8 , 2) 6) (8 , 5) (valid (route (0 , just 0) false 122 20 true ((5 , 2) ∷ (2 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 0))) + ⊕ extend (step true 1 0 false false true true 1 nothing (0 , just 2) (8 , 2) 7) (8 , 9) (valid (route (0 , just 0) false 122 20 true ((9 , 2) ∷ (2 , 4) ∷ (4 , 137) ∷ (137 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 9 0 false false false false 0 nothing (1 , just 1) (4 , 2) 0) (4 , 7) (valid (route (1 , just 1) true 0 7 false ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 2))) + ⊕ extend (step true 9 0 false false false false 0 nothing (1 , just 1) (4 , 2) 0) (4 , 2) (valid (route (1 , just 1) true 0 7 false ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 2))) + ≡ valid (route (1 , just 1) true 0 16 false ((4 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 3 255 false false true true 0 nothing (0 , just 1) (6 , 2) 2) (6 , 7) (valid (route (0 , just 1) false 0 9 false ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 3))) + ⊕ extend (step true 3 255 false false true true 0 nothing (0 , just 1) (6 , 2) 3) (6 , 3) (valid (route (0 , just 1) false 0 9 false ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 3))) + ≡ valid (route (0 , just 1) false 255 12 false ((6 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 2)) +_ = refl + +_ : extend (step true 12 127 true true false false 0 nothing (1 , just 1) (7 , 2) 0) (7 , 2) (valid (route (1 , just 1) false 127 4 false ((2 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 5))) + ⊕ extend (step true 12 127 true true false false 0 nothing (1 , just 1) (7 , 2) 0) (7 , 5) (valid (route (1 , just 1) false 127 4 false ((5 , 6) ∷ (6 , 187) ∷ (187 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 5))) + ≡ valid (route (1 , just 1) true 127 16 true ((7 , 2) ∷ (2 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 4 128 false false false false 0 nothing (1 , just 1) (9 , 2) 0) (9 , 6) (valid (route (1 , just 1) true 127 5 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 8))) + ⊕ extend (step true 4 128 false false false false 0 nothing (1 , just 1) (9 , 2) 0) (9 , 4) (valid (route (1 , just 1) true 127 5 false ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 8))) + ≡ valid (route (1 , just 1) true 128 9 false ((9 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 1 122 false false false false 0 nothing (2 , just 0) (2 , 2) 0) (2 , 6) (valid (route (1 , just 0) true 128 10 false ((6 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 7))) + ⊕ extend (step true 7 0 false false false false 0 nothing (2 , just 0) (2 , 2) 0) (2 , 5) (valid (route (0 , just 0) false 127 6 false ((5 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 8))) + ≡ valid (route (0 , just 0) false 127 13 false ((2 , 5) ∷ (5 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 5 122 true true false false 0 nothing (2 , just 1) (6 , 2) 0) (6 , 4) (valid (route (1 , just 1) true 255 1 false ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 1))) + ⊕ extend (step true 5 122 true true false false 0 nothing (2 , just 1) (6 , 2) 0) (6 , 9) (valid (route (1 , just 1) true 255 1 false ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 1))) + ≡ valid (route (1 , just 1) true 255 6 true ((6 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 5 0 true false false false 0 nothing (0 , just 2) (7 , 2) 0) (7 , 4) (valid (route (0 , just 2) false 122 1 true ((4 , 2) ∷ (2 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 1) , 7))) + ⊕ extend (step true 5 0 true false false false 0 nothing (0 , just 2) (7 , 2) 0) (7 , 6) (valid (route (0 , just 2) false 122 1 true ((6 , 2) ∷ (2 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 7))) + ≡ valid (route (0 , just 2) true 122 6 true ((7 , 4) ∷ (4 , 2) ∷ (2 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 11 0 false false false false 0 nothing (0 , just 1) (9 , 2) 0) (9 , 4) (valid (route (0 , just 1) false 128 4 false ((4 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 0) , 2))) + ⊕ extend (step true 6 255 false false false false 0 nothing (0 , just 1) (9 , 2) 0) (9 , 5) (valid (route (0 , just 2) true 122 6 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 7))) + ≡ valid (route (0 , just 2) true 255 12 false ((9 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 6 255 false false false false 0 nothing (0 , just 1) (6 , 2) 0) (6 , 4) (valid (route (0 , just 1) false 122 10 false ((4 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 1))) + ⊕ extend (step true 6 255 false true false false 0 nothing (0 , just 1) (6 , 2) 0) (6 , 7) (valid (route (0 , just 1) false 122 10 false ((7 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 1))) + ≡ valid (route (0 , just 1) false 255 16 false ((6 , 4) ∷ (4 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 1 255 false true false true 1 nothing (1 , just 0) (4 , 1) 2) (4 , 9) (valid (route (0 , just 0) false 255 5 true ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 1) , 1))) + ⊕ extend (step true 1 255 false false false true 1 nothing (1 , just 0) (4 , 1) 3) (4 , 6) (valid (route (0 , just 0) false 255 5 true ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 1) , 1))) + ≡ valid (route (1 , just 0) false 255 6 true ((4 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 1) , 2)) +_ = refl + +_ : extend (step true 8 255 false false false false 0 nothing (0 , just 0) (5 , 2) 0) (5 , 3) (valid (route (0 , just 0) false 122 3 false ((3 , 8) ∷ (8 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 5))) + ⊕ extend (step true 8 255 false false false false 0 nothing (0 , just 0) (5 , 2) 0) (5 , 2) (valid (route (0 , just 0) false 122 3 false ((2 , 8) ∷ (8 , 7) ∷ (7 , 176) ∷ (176 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 5))) + ≡ valid (route (0 , just 0) false 255 11 false ((5 , 3) ∷ (3 , 8) ∷ (8 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 4 127 false false true true 1 nothing (0 , just 2) (3 , 2) 4) (3 , 8) (valid (route (1 , just 0) false 255 21 true ((8 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 0))) + ⊕ extend (step true 4 127 false true true true 1 nothing (0 , just 2) (3 , 2) 5) (3 , 5) (valid (route (1 , just 0) false 255 21 true ((5 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 4 127 false true false true 1 nothing (1 , just 1) (3 , 2) 6) (3 , 6) (valid (route (1 , just 1) false 255 6 false ((6 , 9) ∷ (9 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 1))) + ⊕ extend (step true 4 127 false false false true 0 nothing (1 , just 1) (3 , 2) 7) (3 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) false 127 4 false ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 7)) +_ = refl + +_ : extend (step true 3 127 false false false true 0 nothing (1 , just 1) (4 , 1) 2) (4 , 6) (valid (route (1 , just 1) false 127 1 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 5))) + ⊕ extend (step true 3 127 false true false true 0 nothing (1 , just 1) (4 , 1) 3) (4 , 9) (valid (route (1 , just 1) false 127 1 false ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 5))) + ≡ valid (route (1 , just 1) false 127 4 false ((4 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 0) , 2)) +_ = refl + +_ : extend (step true 6 127 false true false false 0 nothing (0 , just 1) (3 , 1) 0) (3 , 2) (valid (route (0 , just 1) true 255 3 true ((2 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 6))) + ⊕ extend (step true 10 255 false true false false 0 nothing (0 , just 1) (3 , 1) 0) (3 , 6) (valid (route (0 , just 0) true 122 4 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 5))) + ≡ valid (route (0 , just 1) true 255 9 true ((3 , 2) ∷ (2 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 6 127 false false false false 0 nothing (1 , just 1) (2 , 1) 0) (2 , 4) (valid (route (1 , just 1) false 122 7 false ((4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 0) , 6))) + ⊕ extend (step true 6 127 false false false false 0 nothing (1 , just 1) (2 , 1) 0) (2 , 5) (valid (route (1 , just 1) false 122 7 false ((5 , 3) ∷ (3 , 183) ∷ (183 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 6))) + ≡ valid (route (1 , just 1) false 127 13 false ((2 , 4) ∷ (4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 9 128 true false false false 0 nothing (1 , just 1) (3 , 2) 0) (3 , 9) (valid (route (1 , just 1) true 0 9 true ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 1) , 6))) + ⊕ extend (step true 4 122 false true false false 0 nothing (1 , just 1) (3 , 2) 0) (3 , 6) (valid (route (0 , just 1) false 128 0 true ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 6))) + ≡ valid (route (0 , just 1) false 128 4 true ((3 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 12 122 false false false false 0 nothing (1 , just 0) (2 , 1) 0) (2 , 6) (valid (route (1 , just 0) false 122 3 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 2))) + ⊕ extend (step true 12 122 false true false false 0 nothing (1 , just 0) (2 , 1) 0) (2 , 3) (valid (route (1 , just 0) false 122 3 false ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 0) , 2))) + ≡ valid (route (1 , just 0) false 122 15 false ((2 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 1 127 false true false true 1 nothing (2 , just 2) (9 , 2) 3) (9 , 8) (valid (route (1 , just 2) false 255 7 true ((8 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 0))) + ⊕ extend (step true 2 122 false false true true 1 nothing (2 , just 2) (9 , 2) 6) (9 , 6) (valid (route (1 , just 1) false 122 4 true ((6 , 4) ∷ (4 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 9))) + ≡ valid (route (2 , just 2) false 255 8 true ((9 , 8) ∷ (8 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 1) , 3)) +_ = refl + +_ : extend (step true 2 0 true false false true 1 nothing (2 , just 2) (3 , 2) 1) (3 , 2) (valid (route (1 , just 2) false 255 3 true ((2 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 1) , 0))) + ⊕ extend (step true 2 0 true false false true 1 nothing (2 , just 2) (3 , 2) 2) (3 , 4) (valid (route (1 , just 2) false 255 3 true ((4 , 6) ∷ (6 , 174) ∷ (174 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 1) , 0))) + ≡ valid (route (2 , just 2) true 255 5 true ((3 , 2) ∷ (2 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 1) , 1)) +_ = refl + +_ : extend (step true 5 122 false true false false 0 nothing (2 , just 1) (7 , 2) 0) (7 , 4) (valid (route (1 , just 1) false 127 11 false ((4 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 0) , 7))) + ⊕ extend (step true 5 122 false true false false 0 nothing (2 , just 1) (7 , 2) 0) (7 , 9) (valid (route (1 , just 1) false 127 11 false ((9 , 8) ∷ (8 , 144) ∷ (144 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 7))) + ≡ valid (route (1 , just 1) false 127 16 true ((7 , 4) ∷ (4 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 4 127 false false false true 1 nothing (1 , just 0) (4 , 2) 4) (4 , 2) (valid (route (0 , just 0) true 255 14 true ((2 , 7) ∷ (7 , 3) ∷ (3 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 0))) + ⊕ extend (step true 4 127 false false false true 1 nothing (1 , just 0) (4 , 2) 5) (4 , 9) (valid (route (0 , just 0) true 255 14 true ((9 , 7) ∷ (7 , 3) ∷ (3 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 0))) + ≡ valid (route (1 , just 0) true 255 18 true ((4 , 2) ∷ (2 , 7) ∷ (7 , 3) ∷ (3 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 1) , 4)) +_ = refl + +_ : extend (step true 5 0 true false false false 0 nothing (1 , just 0) (3 , 1) 0) (3 , 7) (valid (route (1 , just 0) false 122 4 false ((7 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 1))) + ⊕ extend (step true 2 255 false false false true 0 nothing (1 , just 0) (3 , 1) 8) (3 , 9) (valid (route (1 , just 2) false 0 3 true ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 1) , 6))) + ≡ valid (route (1 , just 2) false 255 5 true ((3 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 8)) +_ = refl + +_ : extend (step true 2 255 false true false false 0 nothing (0 , just 2) (9 , 1) 0) (9 , 3) (valid (route (0 , just 2) false 122 11 false ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 2))) + ⊕ extend (step true 2 255 false true false false 0 nothing (0 , just 2) (9 , 1) 0) (9 , 6) (valid (route (0 , just 2) false 122 11 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 2))) + ≡ valid (route (0 , just 2) false 255 13 true ((9 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 2 122 true false false true 1 nothing (0 , just 1) (9 , 1) 8) (9 , 7) (valid (route (0 , just 1) false 127 18 true ((7 , 2) ∷ (2 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 0))) + ⊕ extend (step true 8 0 true true false false 0 nothing (0 , just 1) (9 , 1) 0) (9 , 8) (valid (route (0 , just 1) false 0 3 true ((8 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 1) , 2))) + ≡ valid (route (0 , just 1) true 0 11 true ((9 , 8) ∷ (8 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 2 122 false false false true 1 nothing (2 , just 1) (5 , 2) 3) (5 , 6) (valid (route (1 , just 1) false 128 0 true ((6 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 2))) + ⊕ extend (step true 4 0 false false false false 0 nothing (2 , just 1) (5 , 2) 0) (5 , 2) (valid (route (1 , just 1) false 127 1 true ((2 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 5))) + ≡ valid (route (1 , just 1) false 127 5 true ((5 , 2) ∷ (2 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 4 255 false false false true 0 nothing (0 , just 1) (9 , 2) 5) (9 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ⊕ extend (step true 4 128 true false false false 0 nothing (0 , just 1) (9 , 2) 0) (9 , 5) (valid (route (0 , just 2) true 128 9 false ((5 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 1))) + ≡ valid (route (0 , just 2) true 128 13 false ((9 , 5) ∷ (5 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 2 0 false false true true 1 nothing (2 , just 1) (3 , 1) 7) (3 , 4) (valid (route (1 , just 1) true 255 11 false ((4 , 7) ∷ (7 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 0))) + ⊕ extend (step true 2 0 false true true true 1 nothing (2 , just 1) (3 , 1) 8) (3 , 8) (valid (route (1 , just 1) true 255 11 false ((8 , 7) ∷ (7 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 0))) + ≡ valid (route (2 , just 1) true 255 13 false ((3 , 4) ∷ (4 , 7) ∷ (7 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 0) , 7)) +_ = refl + +_ : extend (step true 3 255 false true false true 0 nothing (0 , just 1) (5 , 2) 8) (5 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ⊕ extend (step true 8 127 false false false false 0 nothing (0 , just 1) (5 , 2) 0) (5 , 3) (valid (route (0 , just 0) false 255 1 false ((3 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 3))) + ≡ valid (route (0 , just 1) false 255 3 true ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 1) , 8)) +_ = refl + +_ : extend (step true 1 128 true false false true 1 nothing (1 , just 2) (4 , 2) 6) (4 , 7) (valid (route (0 , just 2) false 128 5 true ((7 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 1) , 8))) + ⊕ extend (step true 1 128 true false false true 1 nothing (1 , just 2) (4 , 2) 7) (4 , 2) (valid (route (0 , just 2) false 128 5 true ((2 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 8))) + ≡ valid (route (1 , just 2) true 128 6 true ((4 , 7) ∷ (7 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 1) , 6)) +_ = refl + +_ : extend (step true 1 127 false false false true 1 nothing (2 , just 2) (7 , 1) 9) (7 , 9) (valid (route (1 , just 2) false 128 14 false ((9 , 6) ∷ (6 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 0))) + ⊕ extend (step true 1 127 false false false true 1 nothing (2 , just 2) (7 , 1) 1) (7 , 5) (valid (route (1 , just 2) false 128 14 false ((5 , 6) ∷ (6 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 0))) + ≡ valid (route (2 , just 2) false 128 15 false ((7 , 5) ∷ (5 , 6) ∷ (6 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 1)) +_ = refl + +_ : extend (step true 2 128 false true false true 1 nothing (2 , just 2) (5 , 2) 8) (5 , 3) (valid (route (1 , just 2) false 127 1 false ((3 , 2) ∷ (2 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 4))) + ⊕ extend (step true 4 128 true false false true 0 nothing (2 , just 2) (5 , 2) 2) (5 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) true 128 4 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 2)) +_ = refl + +_ : extend (step true 1 0 true false false true 0 nothing (0 , just 1) (9 , 2) 7) (9 , 6) (valid (route (0 , just 1) false 122 8 false ((6 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 8))) + ⊕ extend (step true 4 128 false false false true 0 nothing (0 , just 1) (9 , 2) 2) (9 , 5) (valid (route (1 , just 2) false 0 8 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 7))) + ≡ valid (route (0 , just 1) true 122 9 false ((9 , 6) ∷ (6 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 7)) +_ = refl + +_ : extend (step true 12 0 false false false false 0 nothing (1 , just 0) (8 , 2) 0) (8 , 3) (valid (route (0 , just 0) false 0 7 false ((3 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 0) , 1))) + ⊕ extend (step true 2 0 false false false false 0 nothing (1 , just 0) (8 , 2) 0) (8 , 7) (valid (route (0 , just 0) false 127 5 false ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 5))) + ≡ valid (route (0 , just 0) false 0 19 false ((8 , 3) ∷ (3 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 4 122 false false false true 1 nothing (0 , just 2) (5 , 2) 6) (5 , 8) (valid (route (0 , just 2) false 255 13 false ((8 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 0))) + ⊕ extend (step true 4 122 false false false true 1 nothing (0 , just 2) (5 , 2) 7) (5 , 3) (valid (route (0 , just 2) false 255 13 false ((3 , 6) ∷ (6 , 100) ∷ (100 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 3 0 false false false false 0 nothing (0 , just 2) (6 , 1) 0) (6 , 9) (valid (route (1 , just 2) false 127 6 false ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 5))) + ⊕ extend (step true 3 0 false false true true 1 nothing (0 , just 2) (6 , 1) 2) (6 , 5) (valid (route (1 , just 0) false 127 15 true ((5 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 1) , 0))) + ≡ invalid +_ = refl + +_ : extend (step true 12 127 false false false false 0 nothing (0 , just 1) (6 , 1) 0) (6 , 7) (valid (route (0 , just 1) true 255 7 false ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 2))) + ⊕ extend (step true 12 127 false false false false 0 nothing (0 , just 1) (6 , 1) 0) (6 , 2) (valid (route (0 , just 1) true 255 7 false ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 2))) + ≡ valid (route (0 , just 1) true 255 19 false ((6 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 3 255 false true false true 0 nothing (1 , just 1) (8 , 1) 3) (8 , 7) (valid (route (1 , just 1) false 128 10 true ((7 , 5) ∷ (5 , 3) ∷ (3 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 0))) + ⊕ extend (step true 4 255 false false false true 0 nothing (1 , just 1) (8 , 1) 2) (8 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) false 255 4 false ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 2)) +_ = refl + +_ : extend (step true 3 128 true false false false 0 nothing (0 , just 1) (6 , 1) 0) (6 , 3) (valid (route (0 , just 1) true 127 7 false ((3 , 9) ∷ (9 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 6))) + ⊕ extend (step true 7 127 false true false false 0 nothing (0 , just 1) (6 , 1) 0) (6 , 7) (valid (route (0 , just 2) false 255 0 false ((7 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 7))) + ≡ valid (route (0 , just 2) false 255 7 true ((6 , 7) ∷ (7 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 12 122 false false false false 0 nothing (1 , just 2) (3 , 1) 0) (3 , 9) (valid (route (1 , just 2) false 128 11 false ((9 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 5))) + ⊕ extend (step true 12 122 false false false false 0 nothing (1 , just 2) (3 , 1) 0) (3 , 8) (valid (route (1 , just 2) false 128 11 false ((8 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 5))) + ≡ valid (route (1 , just 2) false 128 23 false ((3 , 8) ∷ (8 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 5 0 false false false false 0 nothing (0 , just 2) (2 , 1) 0) (2 , 4) (valid (route (0 , just 2) false 127 9 false ((4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 0) , 3))) + ⊕ extend (step true 5 0 false false false false 0 nothing (0 , just 2) (2 , 1) 0) (2 , 9) (valid (route (0 , just 2) false 127 9 false ((9 , 3) ∷ (3 , 183) ∷ (183 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 3))) + ≡ valid (route (0 , just 2) false 127 14 false ((2 , 4) ∷ (4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 4 128 false true false true 1 nothing (2 , just 2) (8 , 1) 6) (8 , 4) (valid (route (1 , just 2) false 255 15 true ((4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 0))) + ⊕ extend (step true 4 128 false true false true 1 nothing (2 , just 2) (8 , 1) 7) (8 , 2) (valid (route (1 , just 2) false 255 15 true ((2 , 3) ∷ (3 , 156) ∷ (156 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 0))) + ≡ valid (route (2 , just 2) false 255 19 true ((8 , 4) ∷ (4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 1) , 6)) +_ = refl + +_ : extend (step true 2 127 true false false true 0 nothing (0 , just 0) (5 , 2) 2) (5 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ⊕ extend (step true 8 127 false false false false 0 nothing (0 , just 0) (5 , 2) 0) (5 , 4) (valid (route (1 , just 0) false 122 0 false ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 0) , 1))) + ≡ valid (route (0 , just 0) true 127 2 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 2)) +_ = refl + +_ : extend (step true 1 127 false false true true 1 nothing (2 , just 2) (9 , 2) 6) (9 , 7) (valid (route (1 , just 2) false 255 7 false ((7 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 3))) + ⊕ extend (step true 1 127 false false true true 1 nothing (2 , just 2) (9 , 2) 7) (9 , 4) (valid (route (1 , just 2) false 255 7 false ((4 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 3))) + ≡ valid (route (2 , just 2) false 255 8 false ((9 , 7) ∷ (7 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 6)) +_ = refl + +_ : extend (step true 8 122 false false false false 0 nothing (0 , just 0) (3 , 2) 0) (3 , 9) (valid (route (0 , just 0) true 255 5 false ((9 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 9))) + ⊕ extend (step true 8 122 false false false false 0 nothing (0 , just 0) (3 , 2) 0) (3 , 8) (valid (route (0 , just 0) true 255 5 false ((8 , 6) ∷ (6 , 152) ∷ (152 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 9))) + ≡ valid (route (0 , just 0) true 255 13 false ((3 , 9) ∷ (9 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 3 122 true false false false 0 nothing (0 , just 1) (9 , 1) 0) (9 , 7) (valid (route (0 , just 1) false 128 0 false ((7 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 2))) + ⊕ extend (step true 9 255 false true false false 0 nothing (0 , just 1) (9 , 1) 0) (9 , 3) (valid (route (0 , just 2) false 127 10 true ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 1) , 3))) + ≡ valid (route (0 , just 2) false 255 19 true ((9 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 3 127 true false false true 0 nothing (0 , just 1) (6 , 2) 5) (6 , 4) (valid (route (0 , just 1) false 255 8 false ((4 , 3) ∷ (3 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 1))) + ⊕ extend (step true 3 128 false true false true 1 nothing (0 , just 1) (6 , 2) 3) (6 , 9) (valid (route (0 , just 0) false 122 8 true ((9 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 1) , 2))) + ≡ valid (route (0 , just 1) true 255 11 false ((6 , 4) ∷ (4 , 3) ∷ (3 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 5)) +_ = refl + +_ : extend (step true 2 127 false false false true 1 nothing (2 , just 2) (7 , 2) 4) (7 , 5) (valid (route (1 , just 2) true 255 12 false ((5 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 0))) + ⊕ extend (step true 2 127 false false false true 1 nothing (2 , just 2) (7 , 2) 5) (7 , 8) (valid (route (1 , just 2) true 255 12 false ((8 , 9) ∷ (9 , 160) ∷ (160 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 0))) + ≡ valid (route (2 , just 2) true 255 14 false ((7 , 5) ∷ (5 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 4)) +_ = refl + +_ : extend (step true 3 0 true true true true 1 nothing (2 , just 0) (2 , 2) 2) (2 , 7) (valid (route (1 , just 0) true 0 11 false ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 2))) + ⊕ extend (step true 1 127 true true false true 1 nothing (2 , just 0) (2 , 2) 3) (2 , 4) (valid (route (0 , just 2) false 255 1 false ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 3))) + ≡ valid (route (1 , just 2) true 255 2 true ((2 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 3)) +_ = refl + +_ : extend (step true 11 127 true false false false 0 nothing (1 , just 0) (2 , 2) 0) (2 , 7) (valid (route (0 , just 0) false 122 0 false ((7 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 8))) + ⊕ extend (step true 1 122 false false false true 0 nothing (1 , just 0) (2 , 2) 8) (2 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 122 1 false ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 8)) +_ = refl + +_ : extend (step true 1 122 false false false true 1 nothing (1 , just 1) (8 , 1) 2) (8 , 5) (valid (route (0 , just 1) false 128 4 true ((5 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 1) , 8))) + ⊕ extend (step true 1 122 false false false true 1 nothing (1 , just 1) (8 , 1) 3) (8 , 4) (valid (route (0 , just 1) false 128 4 true ((4 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 1) , 8))) + ≡ valid (route (1 , just 1) false 128 5 true ((8 , 5) ∷ (5 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 1) , 2)) +_ = refl + +_ : extend (step true 2 127 false false false true 1 nothing (3 , just 2) (5 , 1) 9) (5 , 9) (valid (route (1 , just 2) false 0 1 false ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 1))) + ⊕ extend (step true 2 127 false true false true 1 nothing (3 , just 2) (5 , 1) 1) (5 , 4) (valid (route (1 , just 2) false 0 1 false ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 0) , 1))) + ≡ valid (route (2 , just 2) false 127 3 false ((5 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 9)) +_ = refl + +_ : extend (step true 1 255 false false false false 0 nothing (0 , just 1) (9 , 1) 0) (9 , 4) (valid (route (0 , just 1) false 128 7 true ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 1) , 1))) + ⊕ extend (step true 4 255 false false false true 1 nothing (0 , just 1) (9 , 1) 8) (9 , 5) (valid (route (0 , just 1) false 128 5 false ((5 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 4))) + ≡ valid (route (0 , just 1) false 255 8 true ((9 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 4 127 false false false true 1 nothing (1 , just 2) (5 , 1) 5) (5 , 7) (valid (route (0 , just 2) false 122 9 false ((7 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 3))) + ⊕ extend (step true 3 128 true true false true 0 nothing (1 , just 2) (5 , 1) 1) (5 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) true 128 3 true ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 1) , 1)) +_ = refl + +_ : extend (step true 1 255 true false false true 0 nothing (0 , just 2) (2 , 2) 7) (2 , 4) (valid (route (0 , just 2) true 127 8 true ((4 , 9) ∷ (9 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 1) , 4))) + ⊕ extend (step true 1 255 true false false true 0 nothing (0 , just 2) (2 , 2) 8) (2 , 8) (valid (route (0 , just 2) true 127 8 true ((8 , 9) ∷ (9 , 5) ∷ (5 , 103) ∷ (103 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 1) , 4))) + ≡ valid (route (0 , just 2) true 255 9 true ((2 , 4) ∷ (4 , 9) ∷ (9 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 1) , 7)) +_ = refl + +_ : extend (step true 7 255 false false false false 0 nothing (1 , just 0) (4 , 1) 0) (4 , 2) (valid (route (1 , just 0) false 122 6 false ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 2))) + ⊕ extend (step true 5 0 false false false false 0 nothing (1 , just 0) (4 , 1) 0) (4 , 5) (valid (route (1 , just 0) false 255 5 false ((5 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 6))) + ≡ valid (route (1 , just 0) false 255 10 false ((4 , 5) ∷ (5 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 7 255 true false false false 0 nothing (1 , just 1) (5 , 1) 0) (5 , 9) (valid (route (1 , just 1) false 127 1 false ((9 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 6))) + ⊕ extend (step true 1 127 false false false true 0 nothing (1 , just 1) (5 , 1) 7) (5 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 1) false 127 1 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 7)) +_ = refl + +_ : extend (step true 2 122 false false false true 0 nothing (0 , just 2) (2 , 2) 4) (2 , 9) (valid (route (0 , just 2) false 0 3 false ((9 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 4))) + ⊕ extend (step true 4 127 false true false false 0 nothing (0 , just 2) (2 , 2) 0) (2 , 5) (valid (route (0 , just 0) false 127 8 false ((5 , 9) ∷ (9 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 1))) + ≡ valid (route (0 , just 2) false 122 5 false ((2 , 9) ∷ (9 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 4)) +_ = refl + +_ : extend (step true 8 122 false true false false 0 nothing (0 , just 0) (4 , 1) 0) (4 , 2) (valid (route (0 , just 0) false 122 1 false ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 1))) + ⊕ extend (step true 2 122 false true false false 0 nothing (0 , just 0) (4 , 1) 0) (4 , 3) (valid (route (0 , just 0) true 128 4 false ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 9))) + ≡ valid (route (0 , just 0) false 122 9 true ((4 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 4 0 false false false true 0 nothing (1 , just 2) (7 , 1) 2) (7 , 2) (valid (route (1 , just 2) false 127 6 true ((2 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 1) , 0))) + ⊕ extend (step true 2 122 false false false true 0 nothing (1 , just 2) (7 , 1) 8) (7 , 9) (valid (route (0 , just 2) true 0 1 true ((9 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 1) , 8))) + ≡ valid (route (0 , just 2) true 122 3 true ((7 , 9) ∷ (9 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 1) , 8)) +_ = refl + +_ : extend (step true 6 122 false false false false 0 nothing (0 , just 2) (3 , 2) 0) (3 , 8) (valid (route (0 , just 2) false 128 3 true ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 1) , 2))) + ⊕ extend (step true 2 122 false true false true 0 nothing (0 , just 2) (3 , 2) 7) (3 , 1) (valid (route (0 , just 2) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 2) false 122 2 true ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 1) , 7)) +_ = refl + +_ : extend (step true 2 127 true true false true 0 nothing (1 , just 0) (7 , 2) 6) (7 , 3) (valid (route (1 , just 0) false 255 4 false ((3 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 5))) + ⊕ extend (step true 3 127 false false false true 0 nothing (1 , just 0) (7 , 2) 5) (7 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 127 3 false ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 5)) +_ = refl + +_ : extend (step true 1 127 false false false false 0 nothing (0 , just 1) (5 , 1) 0) (5 , 8) (valid (route (0 , just 1) false 122 5 false ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 0) , 5))) + ⊕ extend (step true 10 122 false true false false 0 nothing (0 , just 1) (5 , 1) 0) (5 , 6) (valid (route (1 , just 1) false 255 4 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 9))) + ≡ valid (route (0 , just 1) false 127 6 false ((5 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 2 128 false true false false 0 nothing (0 , just 1) (2 , 1) 0) (2 , 7) (valid (route (0 , just 1) false 255 7 true ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 1) , 9))) + ⊕ extend (step true 2 128 false true false false 0 nothing (0 , just 1) (2 , 1) 0) (2 , 8) (valid (route (0 , just 1) false 255 7 true ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 1) , 9))) + ≡ valid (route (0 , just 1) false 255 9 true ((2 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 3 127 false false false true 1 nothing (2 , just 0) (7 , 1) 4) (7 , 8) (valid (route (1 , just 0) true 128 13 true ((8 , 5) ∷ (5 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 1) , 0))) + ⊕ extend (step true 1 128 false true true true 0 nothing (2 , just 0) (7 , 1) 8) (7 , 5) (valid (route (0 , just 0) true 255 2 false ((5 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 7))) + ≡ valid (route (0 , just 0) true 255 3 true ((7 , 5) ∷ (5 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 1) , 8)) +_ = refl + +_ : extend (step true 6 127 false false false false 0 nothing (0 , just 0) (6 , 2) 0) (6 , 4) (valid (route (0 , just 0) true 0 2 true ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 1) , 8))) + ⊕ extend (step true 6 127 false false false false 0 nothing (0 , just 0) (6 , 2) 0) (6 , 7) (valid (route (0 , just 0) true 0 2 true ((7 , 160) ∷ (160 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 1) , 8))) + ≡ valid (route (0 , just 0) true 127 8 true ((6 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 1 122 false true false true 0 nothing (1 , just 0) (6 , 2) 3) (6 , 5) (valid (route (0 , just 0) false 128 8 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 2))) + ⊕ extend (step true 1 122 false false false false 0 nothing (1 , just 0) (6 , 2) 0) (6 , 4) (valid (route (1 , just 2) false 122 9 false ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 7))) + ≡ valid (route (0 , just 0) false 128 9 true ((6 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 3)) +_ = refl + +_ : extend (step true 4 0 false false false true 0 nothing (0 , just 2) (5 , 1) 5) (5 , 8) (valid (route (0 , just 1) false 128 9 false ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 3))) + ⊕ extend (step true 4 0 false false false true 0 nothing (0 , just 2) (5 , 1) 6) (5 , 9) (valid (route (0 , just 1) false 128 9 false ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 3))) + ≡ invalid +_ = refl + +_ : extend (step true 9 127 true true false false 0 nothing (0 , just 0) (6 , 2) 0) (6 , 7) (valid (route (0 , just 0) false 255 10 true ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 1) , 7))) + ⊕ extend (step true 2 128 true false false false 0 nothing (0 , just 0) (6 , 2) 0) (6 , 4) (valid (route (0 , just 1) false 128 11 true ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 1) , 1))) + ≡ valid (route (0 , just 1) true 128 13 true ((6 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 12 128 false false false false 0 nothing (0 , just 1) (6 , 2) 0) (6 , 5) (valid (route (0 , just 1) false 122 7 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 4))) + ⊕ extend (step true 12 128 false true false false 0 nothing (0 , just 1) (6 , 2) 0) (6 , 3) (valid (route (0 , just 1) false 122 7 false ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 4))) + ≡ valid (route (0 , just 1) false 128 19 false ((6 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 2 128 false true true true 0 nothing (1 , just 0) (3 , 1) 7) (3 , 6) (valid (route (0 , just 2) false 255 1 true ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 1) , 5))) + ⊕ extend (step true 2 128 false false true true 0 nothing (1 , just 0) (3 , 1) 8) (3 , 7) (valid (route (0 , just 2) false 255 1 true ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 1) , 5))) + ≡ invalid +_ = refl + +_ : extend (step true 2 0 true false true true 1 nothing (0 , just 0) (5 , 1) 9) (5 , 4) (valid (route (0 , just 2) false 127 7 true ((4 , 8) ∷ (8 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 0) , 0))) + ⊕ extend (step true 2 0 false true false false 0 nothing (0 , just 0) (5 , 1) 0) (5 , 3) (valid (route (1 , just 0) false 255 8 false ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 0) , 7))) + ≡ invalid +_ = refl + +_ : extend (step true 10 255 true false false false 0 nothing (1 , just 1) (2 , 1) 0) (2 , 5) (valid (route (1 , just 1) false 128 7 false ((5 , 9) ∷ (9 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 6))) + ⊕ extend (step true 10 255 true false false false 0 nothing (1 , just 1) (2 , 1) 0) (2 , 7) (valid (route (1 , just 1) false 128 7 false ((7 , 9) ∷ (9 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 6))) + ≡ valid (route (1 , just 1) true 255 17 false ((2 , 5) ∷ (5 , 9) ∷ (9 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 2 127 true true false true 0 nothing (0 , just 0) (6 , 2) 2) (6 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ⊕ extend (step true 9 122 false true false false 0 nothing (0 , just 0) (6 , 2) 0) (6 , 7) (valid (route (1 , just 2) false 0 6 false ((7 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 5))) + ≡ valid (route (0 , just 0) true 127 2 true ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 2)) +_ = refl + +_ : extend (step true 3 127 false false false false 0 nothing (1 , just 2) (9 , 1) 0) (9 , 2) (valid (route (1 , just 2) false 128 5 false ((2 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 1))) + ⊕ extend (step true 10 255 true false false false 0 nothing (1 , just 2) (9 , 1) 0) (9 , 4) (valid (route (1 , just 0) false 0 9 false ((4 , 5) ∷ (5 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 1))) + ≡ valid (route (1 , just 2) false 128 8 false ((9 , 2) ∷ (2 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 3 127 false true false false 0 nothing (1 , just 0) (3 , 1) 0) (3 , 5) (valid (route (1 , just 0) false 255 8 true ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 1) , 2))) + ⊕ extend (step true 3 127 false true false false 0 nothing (1 , just 0) (3 , 1) 0) (3 , 8) (valid (route (1 , just 0) false 255 8 true ((8 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 1) , 2))) + ≡ valid (route (1 , just 0) false 255 11 true ((3 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 2 128 false false false false 0 nothing (0 , just 1) (9 , 2) 0) (9 , 2) (valid (route (0 , just 1) false 0 0 true ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 6))) + ⊕ extend (step true 10 128 true false false false 0 nothing (0 , just 1) (9 , 2) 0) (9 , 4) (valid (route (1 , just 0) true 122 5 false ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 5))) + ≡ valid (route (0 , just 1) false 128 2 true ((9 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 3 122 true false false true 1 nothing (3 , just 0) (6 , 2) 6) (6 , 9) (valid (route (1 , just 0) true 128 11 false ((9 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 0))) + ⊕ extend (step true 3 122 true false false true 1 nothing (3 , just 0) (6 , 2) 7) (6 , 4) (valid (route (1 , just 0) true 128 11 false ((4 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 0))) + ≡ valid (route (2 , just 0) true 128 14 false ((6 , 9) ∷ (9 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 6)) +_ = refl + +_ : extend (step true 1 122 false true false false 0 nothing (1 , just 2) (2 , 1) 0) (2 , 7) (valid (route (1 , just 2) false 127 4 false ((7 , 6) ∷ (6 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 5))) + ⊕ extend (step true 7 0 false false false false 0 nothing (1 , just 2) (2 , 1) 0) (2 , 5) (valid (route (1 , just 2) false 122 1 false ((5 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 5))) + ≡ valid (route (1 , just 2) false 122 8 false ((2 , 5) ∷ (5 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 7 255 true true false false 0 nothing (1 , just 1) (9 , 1) 0) (9 , 5) (valid (route (0 , just 1) false 128 7 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 1))) + ⊕ extend (step true 10 122 false false false false 0 nothing (1 , just 1) (9 , 1) 0) (9 , 6) (valid (route (0 , just 1) false 255 5 false ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 5))) + ≡ valid (route (0 , just 1) false 255 15 false ((9 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 1 128 false true false true 1 nothing (2 , just 1) (4 , 2) 4) (4 , 7) (valid (route (0 , just 1) false 0 11 true ((7 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 1) , 5))) + ⊕ extend (step true 1 128 false true false true 1 nothing (2 , just 1) (4 , 2) 5) (4 , 3) (valid (route (0 , just 1) false 0 11 true ((3 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((3 , 2 , 1) , 5))) + ≡ valid (route (1 , just 1) false 128 12 true ((4 , 7) ∷ (7 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 1) , 4)) +_ = refl + +_ : extend (step true 2 0 false false false false 0 nothing (1 , just 0) (3 , 1) 0) (3 , 7) (valid (route (0 , just 0) false 128 10 false ((7 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 1))) + ⊕ extend (step true 1 128 true false true true 1 nothing (1 , just 0) (3 , 1) 4) (3 , 5) (valid (route (1 , just 1) true 122 1 true ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 1) , 2))) + ≡ valid (route (0 , just 0) false 128 12 false ((3 , 7) ∷ (7 , 9) ∷ (9 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 3 128 false false false true 1 nothing (1 , just 0) (5 , 1) 8) (5 , 9) (valid (route (0 , just 0) false 127 1 false ((9 , 2) ∷ (2 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 4))) + ⊕ extend (step true 3 128 false false false true 1 nothing (1 , just 0) (5 , 1) 9) (5 , 6) (valid (route (0 , just 0) false 127 1 false ((6 , 2) ∷ (2 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 4))) + ≡ valid (route (1 , just 0) false 128 4 false ((5 , 9) ∷ (9 , 2) ∷ (2 , 7) ∷ (7 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 8)) +_ = refl + +_ : extend (step true 8 0 true true false false 0 nothing (1 , just 0) (2 , 2) 0) (2 , 5) (valid (route (1 , just 0) false 255 0 true ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 1) , 1))) + ⊕ extend (step true 8 0 true true false false 0 nothing (1 , just 0) (2 , 2) 0) (2 , 6) (valid (route (1 , just 0) false 255 0 true ((6 , 1) ∷ (1 , 0) ∷ []) ((6 , 2 , 1) , 1))) + ≡ valid (route (1 , just 0) true 255 8 true ((2 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 2 122 false false false true 0 nothing (1 , just 1) (3 , 1) 1) (3 , 4) (valid (route (1 , just 1) true 122 7 false ((4 , 9) ∷ (9 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 0))) + ⊕ extend (step true 2 122 false false false true 0 nothing (1 , just 1) (3 , 1) 2) (3 , 2) (valid (route (1 , just 1) true 122 7 false ((2 , 9) ∷ (9 , 8) ∷ (8 , 110) ∷ (110 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 0))) + ≡ valid (route (1 , just 1) true 122 9 false ((3 , 4) ∷ (4 , 9) ∷ (9 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 0) , 1)) +_ = refl + +_ : extend (step true 2 255 true true false true 0 nothing (0 , just 0) (2 , 2) 5) (2 , 5) (valid (route (0 , just 0) false 128 4 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 2 , 0) , 1))) + ⊕ extend (step true 4 255 false false false true 0 nothing (0 , just 0) (2 , 2) 1) (2 , 1) (valid (route (0 , just 0) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ≡ valid (route (0 , just 0) false 255 4 false ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 1)) +_ = refl + +_ : extend (step true 2 0 false false false true 0 nothing (0 , just 0) (5 , 2) 7) (5 , 3) (valid (route (1 , just 0) false 0 2 true ((3 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 6))) + ⊕ extend (step true 2 0 false false false true 0 nothing (0 , just 0) (5 , 2) 8) (5 , 8) (valid (route (1 , just 0) false 0 2 true ((8 , 4) ∷ (4 , 140) ∷ (140 , 1) ∷ (1 , 0) ∷ []) ((8 , 2 , 1) , 6))) + ≡ invalid +_ = refl + +_ : extend (step true 4 122 false true true true 0 nothing (0 , just 1) (2 , 2) 3) (2 , 7) (valid (route (0 , just 0) false 128 7 true ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 1) , 5))) + ⊕ extend (step true 4 122 false true true true 0 nothing (0 , just 1) (2 , 2) 4) (2 , 3) (valid (route (0 , just 0) false 128 7 true ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 5))) + ≡ invalid +_ = refl + +_ : extend (step true 9 127 false false false false 0 nothing (1 , just 1) (3 , 2) 0) (3 , 7) (valid (route (1 , just 1) false 0 4 false ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 0) , 7))) + ⊕ extend (step true 9 127 false false false false 0 nothing (1 , just 1) (3 , 2) 0) (3 , 2) (valid (route (1 , just 1) false 0 4 false ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 7))) + ≡ valid (route (1 , just 1) false 127 13 false ((3 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 3 122 false false false true 1 nothing (0 , just 1) (4 , 1) 4) (4 , 6) (valid (route (0 , just 1) true 128 14 false ((6 , 2) ∷ (2 , 1) ∷ (1 , 0) ∷ []) ((2 , 1 , 0) , 0))) + ⊕ extend (step true 8 122 false true false false 0 nothing (0 , just 1) (4 , 1) 0) (4 , 3) (valid (route (0 , just 0) false 255 5 true ((3 , 40) ∷ (40 , 43) ∷ (43 , 52) ∷ (52 , 58) ∷ (58 , 8) ∷ (8 , 51) ∷ (51 , 32) ∷ (32 , 12) ∷ (12 , 29) ∷ (29 , 2) ∷ (2 , 7) ∷ (7 , 35) ∷ (35 , 37) ∷ (37 , 28) ∷ (28 , 9) ∷ (9 , 19) ∷ (19 , 13) ∷ (13 , 53) ∷ (53 , 17) ∷ (17 , 56) ∷ (56 , 45) ∷ (45 , 31) ∷ (31 , 59) ∷ (59 , 54) ∷ (54 , 16) ∷ (16 , 34) ∷ (34 , 50) ∷ (50 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 6))) + ≡ invalid +_ = refl + +_ : extend (step true 3 0 false true false true 0 nothing (0 , just 1) (2 , 1) 9) (2 , 1) (valid (route (0 , just 1) false 0 0 false ((1 , 0) ∷ []) ((0 , 0 , 0) , 0))) + ⊕ extend (step true 1 0 false true false false 0 nothing (0 , just 1) (2 , 1) 0) (2 , 6) (valid (route (0 , just 2) false 127 5 false ((6 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 6))) + ≡ valid (route (0 , just 2) false 127 6 true ((2 , 6) ∷ (6 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((6 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 7 0 false false false false 0 nothing (0 , just 0) (6 , 2) 0) (6 , 2) (valid (route (1 , just 0) false 128 10 false ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 7))) + ⊕ extend (step true 7 0 false false false false 0 nothing (0 , just 0) (6 , 2) 0) (6 , 8) (valid (route (1 , just 0) false 128 10 false ((8 , 115) ∷ (115 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 7))) + ≡ invalid +_ = refl + +_ : extend (step true 2 127 false true false false 0 nothing (1 , just 2) (3 , 2) 0) (3 , 7) (valid (route (1 , just 2) false 128 2 true ((7 , 1) ∷ (1 , 0) ∷ []) ((7 , 1 , 1) , 7))) + ⊕ extend (step true 7 122 false false false false 0 nothing (1 , just 2) (3 , 2) 0) (3 , 4) (valid (route (0 , just 1) false 0 5 true ((4 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 1) , 2))) + ≡ valid (route (0 , just 1) false 122 12 true ((3 , 4) ∷ (4 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 1) , 0)) +_ = refl + +_ : extend (step true 8 122 false true false false 0 nothing (1 , just 1) (8 , 2) 0) (8 , 4) (valid (route (1 , just 1) false 0 6 false ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 0) , 2))) + ⊕ extend (step true 8 122 false true false false 0 nothing (1 , just 1) (8 , 2) 0) (8 , 9) (valid (route (1 , just 1) false 0 6 false ((9 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 2))) + ≡ valid (route (1 , just 1) false 122 14 true ((8 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 0) , 0)) +_ = refl + +_ : extend (step true 3 122 false false false true 1 nothing (1 , just 1) (6 , 1) 9) (6 , 2) (valid (route (1 , just 1) true 122 10 false ((2 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 3))) + ⊕ extend (step true 9 0 true true false false 0 nothing (1 , just 1) (6 , 1) 0) (6 , 3) (valid (route (0 , just 2) false 0 3 true ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 2))) + ≡ valid (route (0 , just 2) true 0 12 true ((6 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 4 255 false true false false 0 nothing (0 , just 1) (3 , 2) 0) (3 , 5) (valid (route (0 , just 0) true 0 8 false ((5 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 1))) + ⊕ extend (step true 4 255 false true false false 0 nothing (0 , just 1) (3 , 2) 0) (3 , 9) (valid (route (0 , just 0) true 0 8 false ((9 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 1))) + ≡ invalid +_ = refl + +_ : extend (step true 1 0 false false false true 1 nothing (2 , just 2) (9 , 1) 9) (9 , 5) (valid (route (1 , just 2) true 122 7 false ((5 , 1) ∷ (1 , 0) ∷ []) ((5 , 1 , 0) , 2))) + ⊕ extend (step true 1 0 false true false true 1 nothing (2 , just 2) (9 , 1) 1) (9 , 4) (valid (route (1 , just 2) true 122 7 false ((4 , 1) ∷ (1 , 0) ∷ []) ((4 , 2 , 0) , 2))) + ≡ valid (route (2 , just 2) true 122 8 false ((9 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((9 , 1 , 0) , 9)) +_ = refl + +_ : extend (step true 11 127 false false false false 0 nothing (0 , just 0) (8 , 2) 0) (8 , 3) (valid (route (1 , just 0) false 122 3 false ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 0) , 7))) + ⊕ extend (step true 11 127 false false false false 0 nothing (0 , just 0) (8 , 2) 0) (8 , 7) (valid (route (1 , just 0) false 122 3 false ((7 , 192) ∷ (192 , 1) ∷ (1 , 0) ∷ []) ((7 , 2 , 0) , 7))) + ≡ invalid +_ = refl + +_ : extend (step true 4 255 true false false false 0 nothing (0 , just 2) (2 , 2) 0) (2 , 3) (valid (route (0 , just 2) false 255 1 true ((3 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 6))) + ⊕ extend (step true 1 128 true true false false 0 nothing (0 , just 2) (2 , 2) 0) (2 , 9) (valid (route (1 , just 2) true 255 11 false ((9 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 5))) + ≡ valid (route (0 , just 2) true 255 5 true ((2 , 3) ∷ (3 , 1) ∷ (1 , 0) ∷ []) ((3 , 1 , 1) , 0)) +_ = refl + +_ : extend (step true 4 122 false false true true 1 nothing (1 , just 0) (5 , 1) 1) (5 , 2) (valid (route (1 , just 0) false 128 8 false ((2 , 8) ∷ (8 , 1) ∷ (1 , 0) ∷ []) ((8 , 1 , 0) , 0))) + ⊕ extend (step true 4 0 true false false false 0 nothing (1 , just 0) (5 , 1) 0) (5 , 2) (valid (route (0 , just 1) false 122 0 false ((2 , 3) ∷ (3 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 8))) + ≡ valid (route (0 , just 1) true 122 4 false ((5 , 2) ∷ (2 , 3) ∷ (3 , 4) ∷ (4 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 0)) +_ = refl + +_ : extend (step true 1 255 false true true true 1 nothing (3 , just 2) (4 , 1) 1) (4 , 8) (valid (route (1 , just 2) true 122 8 false ((8 , 9) ∷ (9 , 6) ∷ (6 , 1) ∷ (1 , 0) ∷ []) ((9 , 2 , 0) , 0))) + ⊕ extend (step true 1 128 false true true true 0 nothing (3 , just 2) (4 , 1) 5) (4 , 2) (valid (route (1 , just 2) false 128 9 false ((2 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((2 , 2 , 0) , 9))) + ≡ valid (route (1 , just 2) false 128 10 true ((4 , 2) ∷ (2 , 5) ∷ (5 , 1) ∷ (1 , 0) ∷ []) ((4 , 1 , 1) , 5)) +_ = refl diff --git a/rs/moq-net/verify/route-algebra/Everything.agda b/rs/moq-net/verify/route-algebra/Everything.agda index a6cc126871b..8a0d4e0967d 100644 --- a/rs/moq-net/verify/route-algebra/Everything.agda +++ b/rs/moq-net/verify/route-algebra/Everything.agda @@ -4,6 +4,7 @@ import Order import Increasing import Route import Claim -import Sim +import Named import Vectors +import ClaimVectors import Accelerate diff --git a/rs/moq-net/verify/route-algebra/Increasing.agda b/rs/moq-net/verify/route-algebra/Increasing.agda index 731b6094c8d..4f6132e7d3c 100644 --- a/rs/moq-net/verify/route-algebra/Increasing.agda +++ b/rs/moq-net/verify/route-algebra/Increasing.agda @@ -1,15 +1,16 @@ -------------------------------------------------------------------------------- -- The algebra both levels of the route rule share, and the theorem it buys. -- --- A route is invalid or carries whether it is draining, a penalty (the lowest --- priority on its path, counted down from the highest), a cost, whether a marked --- link is on its path, its path, and whatever else a level carries in `extra`. --- Routes rank by draining, then penalty, then cost, then unmarked before marked, --- then the shorter path, then a fixed order on paths, then `extra`. Crossing a --- link (`extend`) refuses a route whose path does not start at the link's far end --- or already names its near end, refuses whatever the link's own filter refuses, --- and otherwise can only make the route draining, raise its penalty, add to its --- cost, mark it, and prepend the link to its path. +-- A route is invalid or carries what leads its rank (`lead`: nothing for a route, +-- a claim's precedence), whether it is draining, a penalty (the lowest priority on +-- its path, counted down from the highest), a cost, whether a marked link is on its +-- path, its path, and whatever else a level carries in `extra`. Routes rank by +-- lead, then draining, then penalty, then cost, then unmarked before marked, then +-- the shorter path, then a fixed order on the path and `extra` together. Crossing a +-- link (`extend`) refuses a route whose path does not start at the link's far end or +-- already names its near end, refuses whatever the link's own filter refuses, and +-- otherwise can only raise the lead, make the route draining, raise its penalty, add +-- to its cost, mark it, prepend the link to its path, and set `extra`. -- -- Any such algebra is an increasing path algebra, so Daggitt and Griffin's -- Theorem 5 applies: on every network, from every state, with messages delayed, @@ -21,18 +22,20 @@ -------------------------------------------------------------------------------- open import Data.Bool.Base using (Bool; true; false; _∨_; if_then_else_) -open import Data.List.Base using (List; []; _∷_) +open import Data.List.Base using (List; []; _∷_; length) open import Data.Nat.Base using (ℕ; zero; suc; _+_; _⊔_; z≤n; _^_) +open import Data.Product.Base using (_×_; _,_) open import RoutingLib.Routing.Basics.Path.Uncertified using (Path; Edge) open import Order module Increasing - -- What else a route carries, ordered, with the trivial route's value least. - {E : Set} (OE : Ordered E) (e₀ : E) (e₀-least : ∀ e → Ordered._≤_ OE e₀ e) - -- How paths of equal length order. - (OP : Ordered Path) + -- What leads the rank, ordered, with the trivial route's value least. + {C : Set} (OC : Ordered C) (c₀ : C) (c₀-least : ∀ c → Ordered._≤_ OC c₀ c) + -- What else a route carries, and how routes whose paths are of equal length order, + -- with the trivial route least among those with an empty path. + {E : Set} (e₀ : E) (OT : Ordered (Path × E)) (OT-least : ∀ e → Ordered._≤_ OT ([] , e₀) ([] , e)) where import Algebra.Construct.NaturalChoice.Min as Min @@ -41,7 +44,7 @@ import Data.Bool.Base as Boolᵇ open import Data.Empty using (⊥-elim) open import Data.Fin.Base using (toℕ) import Data.Nat.Properties as ℕ -open import Data.Product.Base using (_×_; _,_; proj₁; proj₂) +open import Data.Product.Base using (proj₁; proj₂) open import Data.Sum.Base using (_⊎_; inj₁; inj₂) open import Level using (0ℓ) open import Relation.Binary.Bundles using (TotalOrder) @@ -53,7 +56,7 @@ open import Relation.Nullary.Negation.Core using (¬_; contradiction) open import RoutingLib.Routing.Algebra import RoutingLib.Routing.Basics.Path.UncertifiedI as PathI -open import RoutingLib.Routing.Basics.Path.Uncertified.Properties using (_⇿?_; _∈ₚ?_; p≉i∷p) +open import RoutingLib.Routing.Basics.Path.Uncertified.Properties using (_⇿?_; _∈ₚ?_) open import RoutingLib.Routing.VectorBased.Convergence.Results ------------------------------------------------------------------------ @@ -62,6 +65,7 @@ open import RoutingLib.Routing.VectorBased.Convergence.Results record Valid : Set where constructor route field + lead : C draining : Bool penalty : ℕ cost : ℕ @@ -77,7 +81,7 @@ data Weight : Set where -- The route a node has to itself. trivial : Weight -trivial = valid (route false 0 0 false [] e₀) +trivial = valid (route c₀ false 0 0 false [] e₀) ------------------------------------------------------------------------ -- What crossing a link does @@ -88,6 +92,8 @@ record Policy : Set₁ where -- The link that is down. down : Link -- What the link adds. + rise : Link → C → C + rise-≥ : ∀ f c → Ordered._≤_ OC c (rise f c) cost : Link → ℕ penalty : Link → ℕ drains : Link → Bool @@ -99,8 +105,8 @@ record Policy : Set₁ where -- Whether the link refuses the route, from the link and the route as offered. refuses : Link → Edge → Valid → Bool down-refuses : ∀ e v → refuses down e v ≡ true - -- How the link changes the rest. - tag : Link → E → E + -- What the route carries beyond the link, from the link and the route as offered. + tag : Link → Edge → Valid → E module Rule (P : Policy) where @@ -116,30 +122,35 @@ module Rule (P : Policy) where ... | no _ | _ = invalid ... | yes _ | yes _ = invalid ... | yes _ | no _ = if refuses f (i , j) v then invalid else valid (route + (P.rise f (lead v)) (draining v ∨ drains f ∨ marks f (i , j) (path v)) (P.penalty f ⊔ penalty v) (P.cost f + cost v) (marked v ∨ P.marked f) ((i , j) ∷ path v) - (tag f (extra v))) + (tag f (i , j) v)) ------------------------------------------------------------------------ -- The order + -- The shorter path first, then by OT. + OL : Ordered (Path × E) + OL = keyed (λ pe → length (proj₁ pe) , pe) (cong proj₂) (lex nat OT) + private - key : Valid → Bool × ℕ × ℕ × Bool × Path × E - key v = draining v , penalty v , cost v , marked v , path v , extra v + key : Valid → C × Bool × ℕ × ℕ × Bool × Path × E + key v = lead v , draining v , penalty v , cost v , marked v , path v , extra v - O₅ = lex (shortlex OP) OE - O₄ = lex bool O₅ + O₅ = lex bool OL + O₄ = lex nat O₅ O₃ = lex nat O₄ - O₂ = lex nat O₃ + O₂ = lex bool O₃ - OK : Ordered (Bool × ℕ × ℕ × Bool × Path × E) - OK = lex bool O₂ + OK : Ordered (C × Bool × ℕ × ℕ × Bool × Path × E) + OK = lex OC O₂ OV : Ordered Valid - OV = keyed key (λ eq → cong (λ (d , q , c , m , p , x) → route d q c m p x) eq) OK + OV = keyed key (λ eq → cong (λ (l , d , q , c , m , p , x) → route l d q c m p x) eq) OK private module OV = Ordered OV @@ -209,19 +220,23 @@ module Rule (P : Policy) where ≤-∨ false b = Bool.≤-minimum b ≤-∨ true b = Bool.≤-reflexive refl - []-least : ∀ p → Ordered._≤_ (shortlex OP) [] p - []-least [] = Ordered.refl (shortlex OP) - []-least (e ∷ p) = inj₁ (z≤n , λ ()) + []-least : ∀ p x → Ordered._≤_ OL ([] , e₀) (p , x) + []-least [] x = lex-≤ nat OT z≤n λ _ → OT-least x + []-least (e ∷ p) x = inj₁ (z≤n , λ ()) + + -- A path is below itself with one more link in front, whatever either carries. + longer : ∀ e p x y → Ordered._≤_ OL (p , x) (e ∷ p , y) + longer e p x y = inj₁ (ℕ.n≤1+n (length p) , ℕ.<⇒≢ (ℕ.n<1+n (length p))) trivial-least : Minimum _≤ᵣ_ trivial trivial-least invalid = below-invalid trivial-least (valid w) = below - (lex-≤ bool O₂ (Bool.≤-minimum (draining w)) λ _ → - lex-≤ nat O₃ z≤n λ _ → + (lex-≤ OC O₂ (c₀-least (lead w)) λ _ → + lex-≤ bool O₃ (Bool.≤-minimum (draining w)) λ _ → lex-≤ nat O₄ z≤n λ _ → - lex-≤ bool O₅ (Bool.≤-minimum (marked w)) λ _ → - lex-≤ (shortlex OP) OE ([]-least (path w)) λ _ → - e₀-least (extra w)) + lex-≤ nat O₅ z≤n λ _ → + lex-≤ bool OL (Bool.≤-minimum (marked w)) λ _ → + []-least (path w) (extra w)) invalid-greatest : Maximum _≤ᵣ_ invalid invalid-greatest _ = below-invalid @@ -237,12 +252,12 @@ module Rule (P : Policy) where ... | yes _ | no _ with refuses f (i , j) v ... | true = below-invalid ... | false = below - (lex-≤ bool O₂ (≤-∨ (draining v) _) λ _ → - lex-≤ nat O₃ (ℕ.m≤n⊔m (P.penalty f) (penalty v)) λ _ → - lex-≤ nat O₄ (ℕ.m≤n+m (cost v) (P.cost f)) λ _ → - lex-≤ bool O₅ (≤-∨ (marked v) _) λ _ → - lex-≤ (shortlex OP) OE (shortlex-∷ OP (i , j) (path v)) λ eq → - contradiction eq p≉i∷p) + (lex-≤ OC O₂ (P.rise-≥ f (lead v)) λ _ → + lex-≤ bool O₃ (≤-∨ (draining v) _) λ _ → + lex-≤ nat O₄ (ℕ.m≤n⊔m (P.penalty f) (penalty v)) λ _ → + lex-≤ nat O₅ (ℕ.m≤n+m (cost v) (P.cost f)) λ _ → + lex-≤ bool OL (≤-∨ (marked v) _) λ _ → + longer (i , j) (path v) (extra v) (tag f (i , j) v)) ------------------------------------------------------------------------ -- The routing algebra diff --git a/rs/moq-net/verify/route-algebra/Named.agda b/rs/moq-net/verify/route-algebra/Named.agda new file mode 100644 index 00000000000..b0240730a63 --- /dev/null +++ b/rs/moq-net/verify/route-algebra/Named.agda @@ -0,0 +1,15 @@ +-------------------------------------------------------------------------------- +-- The route rule with nodes named as the binding names a `NodeId` +-- (`rs/moq-net/src/route/tests/algebra.rs`): 1000 × (2 × start + marked) + relay. +-------------------------------------------------------------------------------- + +module Named where + +open import Data.Nat.Base using (ℕ; _%_; _/_) + +relay start mark : ℕ → ℕ +relay n = n % 1000 +start n = n / 2000 +mark n = (n / 1000) % 2 + +open import Route relay start mark public diff --git a/rs/moq-net/verify/route-algebra/Order.agda b/rs/moq-net/verify/route-algebra/Order.agda index c6c3ce5d8a5..c5b49253036 100644 --- a/rs/moq-net/verify/route-algebra/Order.agda +++ b/rs/moq-net/verify/route-algebra/Order.agda @@ -9,7 +9,8 @@ module Order where import Data.Bool.Base as Boolᵇ open Boolᵇ using (Bool) import Data.Bool.Properties as Bool -open import Data.List.Base using (List; _∷_; length) +open import Data.List.Base using (List) +open import Data.Maybe.Base using (Maybe; nothing; just) import Data.List.Relation.Binary.Lex.NonStrict as ListLex open import Data.List.Relation.Binary.Pointwise using (Pointwise-≡⇒≡; ≡⇒Pointwise-≡) import Data.Nat.Base as ℕᵇ @@ -19,12 +20,14 @@ open import Data.Product.Base using (_×_; _,_; proj₁; proj₂) import Data.Product.Relation.Binary.Lex.NonStrict as ProductLex open import Data.Product.Relation.Binary.Pointwise.NonDependent using (≡×≡⇒≡; ≡⇒≡×≡) open import Data.Sum.Base using (inj₁; inj₂) +open import Function.Base using (flip) open import Level using (0ℓ) open import Relation.Binary.Core using (Rel; _⇒_) open import Relation.Binary.Definitions using (Decidable) open import Relation.Binary.PropositionalEquality.Core using (_≡_; _≢_; refl; cong) import Relation.Binary.PropositionalEquality.Properties as ≡ open import Relation.Binary.Structures using (IsDecTotalOrder) +import Relation.Binary.Construct.Flip.EqAndOrd as Flip open import Relation.Nullary.Decidable.Core using (yes; no; map′) -- A decidable total order on A whose equality is _≡_. @@ -96,10 +99,21 @@ keyed f inj OB = record } where module OB = Ordered OB --- Shorter lists first, then by the given order: a list is always below --- itself with one more element in front. -shortlex : ∀ {A : Set} → Ordered (List A) → Ordered (List A) -shortlex OL = keyed (λ xs → length xs , xs) (λ eq → cong proj₂ eq) (lex nat OL) +-- Higher first. +newest : Ordered ℕ +newest = record { _≤_ = flip ℕᵇ._≤_ ; isDecTotalOrder = Flip.isDecTotalOrder ℕ.≤-isDecTotalOrder } + +-- None first, then the higher. +runs : Ordered (Maybe ℕ) +runs = keyed key key-injective (lex nat newest) + where + key : Maybe ℕ → ℕ × ℕ + key nothing = 0 , 0 + key (just n) = 1 , n + + key-injective : ∀ {x y} → key x ≡ key y → x ≡ y + key-injective {nothing} {nothing} _ = refl + key-injective {just _} {just _} refl = refl ------------------------------------------------------------------------ -- Building a lexicographic comparison one component at a time @@ -116,6 +130,3 @@ module _ {A B : Set} (OA : Ordered A) (OB : Ordered B) where ... | yes eq = inj₂ (eq , k eq) ... | no ne = inj₁ (a≤a' , ne) --- A list is below itself with one more element in front. -shortlex-∷ : ∀ {A : Set} (OL : Ordered (List A)) x xs → Ordered._≤_ (shortlex OL) xs (x ∷ xs) -shortlex-∷ OL x xs = inj₁ (ℕ.n≤1+n (length xs) , ℕ.<⇒≢ (ℕ.n<1+n (length xs))) diff --git a/rs/moq-net/verify/route-algebra/README.md b/rs/moq-net/verify/route-algebra/README.md index afc261f3520..6a04fcfbde8 100644 --- a/rs/moq-net/verify/route-algebra/README.md +++ b/rs/moq-net/verify/route-algebra/README.md @@ -1,8 +1,8 @@ # The route rule's convergence proof -The multicast route rule (`rs/moq-net/src/route/tests/multi.rs` with the epic's -`floor`, `epoch`, `batch`, `drain`, and `claimed`) stated as an increasing path -algebra in Agda, with Daggitt and Griffin's Theorem 5 applied to it +The route rule `route::relay::Router` runs (`rs/moq-net/src/route/relay.rs`), and +the claims that ride on it, stated as increasing path algebras in Agda, with +Daggitt and Griffin's Theorem 5 applied to them ([arXiv 2106.01184](https://arxiv.org/abs/2106.01184), library [MatthewDaggitt/agda-routing](https://github.com/MatthewDaggitt/agda-routing)): on every network, from every state, with messages delayed, reordered, lost, and @@ -28,33 +28,58 @@ about a minute and a half; building the library the first time adds about 40 s. | `Order.agda` | Decidable total orders and the combinators the rank is built from. | | `Increasing.agda` | The algebra both levels share, and the theorem it buys (`convergent`, `converges-n²`). | | `Route.agda` | Routes between forwarding nodes: every filter and the link a node holds. | -| `Claim.agda` | Claims across trust boundaries: the same algebra at the grain of the nodes that hand a claim on. | -| `Sim.agda` | `Route` with nodes named as the Rust simulation names them. | -| `Vectors.agda` | Results the Rust prototype computed, each a `refl` (generated). | +| `Claim.agda` | Claims across trust boundaries: the same algebra at the grain of the relays that hand a claim on. | +| `Named.agda` | `Route` with nodes named as the binding names a `NodeId`. | +| `Vectors.agda` | Route results the router computed, each a `refl` (generated). | +| `ClaimVectors.agda` | Claim results the router computed, each a `refl` (generated). | | `Accelerate.agda` | The floor and the named drains leave the rule's fixed point unchanged. | ## The algebra -A route is invalid or carries whether it is draining, a penalty (127 minus the -lowest priority on its path), a cost, whether a marked link is on its path, its -path, and whatever else a level carries (`extra`). Routes rank by draining, -then penalty, then cost, then unmarked before marked, then the shorter path, -then a fixed order on paths (the neighbour first), then `extra`. A node keeps the -lower of two routes. Crossing a link refuses a route whose path does not start -at the link's far end or already names its near end, and whatever the link's -filter refuses; otherwise it can only make the route draining, raise its -penalty, add to its cost, mark it, and prepend the link. That is an increasing -path algebra, which is all Theorem 5 asks. - -For routes, the link from i to its neighbour j carries: whether it is up, i's -port cost and penalty, whether j sent GOAWAY, the nodes i knows draining, i's -session floors, whether i or j marked the link, whether j announces a claim, -and i's session number. It refuses a route when the link is down, when the -route is j's route to itself and j announces no claim, when the route is -marked and j marked the link, when the path would grow past 32 hops, or when -the path names a session i's floors hold closed. A route that names a node -known draining ranks as draining. Nodes are incarnations: a restart is a new -node. +A route is invalid or carries what leads its rank (nothing for a route, a +claim's precedence), whether it is draining, a penalty (127 minus the lowest +priority on its path), a cost, whether a marked link is on its path, its path, +and whatever else a level carries (`extra`). Routes rank by the lead, then +draining, then penalty, then cost, then unmarked before marked, then the shorter +path, then a fixed order on the path and `extra` that each level gives. A node +keeps the lower of two routes. Crossing a link refuses a route whose path does +not start at the link's far end or already names its near end, and whatever the +link's filter refuses; otherwise it can only raise the lead, make the route +draining, raise its penalty, add to its cost, mark it, prepend the link, and set +`extra`. That is an increasing path algebra, which is all Theorem 5 asks. + +**Routes.** A node is a Node ID: a relay at one start, or that start's marked +identity, which announces what the node took over a marked link. A restart is a +new node. Among equal ranks, marks, and lengths, routes order by the neighbour's +Node ID (relay, start, unmarked first), as `order` does. The link from i to its +neighbour j carries: whether it is up, i's port cost and penalty, whether j sent +GOAWAY, the nodes i knows draining, i's session floors, whether i or j marked +the link, whether j announces a claim, and i's session number. It refuses a +route when the link is down, when the route is j's route to itself and j +announces no claim, when the route is marked and j marked the link, when the +path would grow past 32 hops, when the cost would pass the metric, when the path +names another start of i's relay, or when it names a session i's floors hold +closed. A route that names a node known draining ranks as draining. A node's +marked identity hangs off the node by one free, marked link at session 0, so its +route there is the node's marked route, `[marked identity, node]`, whose marked +hop counts toward the 32. + +**Claims.** The destination is a broadcast: one Instance at one path. A claim +leads with its precedence (a claim exactly at its path before a broader one shown +there, then the newer run) and orders, among equal ranks, marks, and lengths, by +its claimant's Node ID and then the key its holder gives the neighbour that gave +it, as `claim_order` and `restate` do. A step is the publisher's own, which sets +the run; an adoption from an endpoint or across a scoped grant +(`Claim::exported` at the giver, then `Claim::adopted`), which prices and marks +the claim over the link, lowers it where it is shown below its own path, files it +under the adopter or its marked identity, and refuses one the giver marked the +link against or whose path reaches the longest chain; or a domain step +(`Claim::over`), which joins an announcer's claim with the settled route there. +Every step into a node refuses a claim below the best precedence the node knows +of, reachable or not, so the rank chooses only among claims of that precedence, +as `closest` does. A claim's path names each relay that handed it on, then the +publisher and the broadcast: Rust's chain backward, with the holder in front +where it holds another node's claim. ## Coverage @@ -67,29 +92,44 @@ node. its receiver is invalid and a path grows by exactly the hop it crossed; each filter maps a route to invalid; the named drain keeps one order. - The route instance with every filter: claimed, the mark's export filter, the - hop limit, the floor with epochs, and the named drain (`Route`). -- The claim instance: any chain of steps that only add, and refuse a claim - naming the node that takes it, converges too (`Claim`). Echoes never beat - the claims they echo because every step is increasing. + hop limit, the metric, another start of the receiver's relay, the floor with + epochs, and the named drain (`Route`). +- The claim instance with precedence leading, the mark and its export filter, + the chain's limit, the best known precedence, and the claimant and giver order + (`Claim`). Echoes never beat the claims they echo because every step is + increasing. - The floor and the named drains only make the rule arrive sooner: the fixed point of the rule without them is a fixed point with them, given that no floor covers a live session (`FloorsClosed`) and that a node is named draining only once it sent GOAWAY on every live link (`DrainNamed`) (`Accelerate.accelerated-fixed`). -**Bound to the prototype by tests** (`rs/moq-net/src/route/tests/algebra.rs`): -the router's own functions (`Offer::own`, `Offer::onward`, `Here::arrive`, -`order`) meet the axioms on random links and routes, and 322 of their results -(200 single steps and 122 choices between two routes, half of them ties) are -written into `Vectors.agda`, where Agda must compute the same results by `refl`. -A Rust test fails when the file is stale (`ROUTE_VECTORS=write` regenerates -it), and a changed Agda definition fails the nightly check. Mutating any of the -floor, epoch, drain set, mark filter, hop limit, claimed, penalty, cost, drains, -tie-break, tag, or sessions is caught by a vector. This is a sample: no test -shows the Rust functions equal the Agda definitions on every input. +**Bound to the router by tests** (`rs/moq-net/src/route/tests/algebra.rs`): the +router's own functions, which it calls itself, meet the axioms on random links, +routes, and claims, and 656 of their results are written into the two vector +files, where Agda must compute the same results by `refl`: for routes, +`Offer::own`, `Offer::onward`, `Here::arrive`, and `order` (2 of the receiver's +marked route, 200 +single steps, and 134 choices between two routes); for claims, `Claim::over`, +`Claim::exported`, `Claim::adopted`, `precedence`, and `claim_order` (200 single +steps and 120 choices between two candidates). Two thirds of the choices tie up +to the neighbour, the claimant, or the giver, and half of those also change the +mark or lengthen the path, so each tie-break decides some. A Rust test fails +when a file is stale (`ROUTE_VECTORS=write` regenerates both), and a changed +Agda definition fails the nightly check. Planting any of these in the router is +caught by a vector: an unmarked marked route, a marked route sent over a marked +link, a path naming another start of the receiver's relay, the floor ignored, +the hop limit off by one, the named drain ignored, the priority not lowered, the +mark, the neighbour's Node ID, or the path length left out of `order`, the mark +or the claimant left out of `claim_order`, a join that keeps the claim's cost or +drops the route's mark, a claim exported over a marked link, an adopter taking a +chain that names it, keeping the priority, ignoring the port's mark, or never +naming itself, and an older run ranked as the newer. The exporter's own chain +limit is not, since the adopter's is stricter. This is a sample: no test shows +the Rust functions equal the Agda definitions on every input. **Argued on paper** (below): the fixed point is unique with and without the -accelerators; the two hypotheses hold in the prototype; advertising once per +accelerators; the two hypotheses hold in the router; advertising once per burst changes no fixed point; what a node advertises is a function of the latest it heard; the dead-hop and ended withdrawals remove only what the floor does; `claimed` removes only routes no request names; claims settle once routes @@ -97,17 +137,24 @@ do; the tree is loop-free at the fixed point; and the rule as it runs, with the next hop in use, still settles. **Only tested**: the rule as it runs settles, on the rank and mark the fixed -order gives (`sticky.rs`); the floor refuses every route the dead-hop -withdrawal ends (`algebra.rs`, `the_floor_refuses_every_dead_hop`); a grant -never improves a claim in the real router (`a_grant_never_improves_a_claim`). +order gives (`sticky.rs`, on `relay::Router`); the floor refuses every route the +dead-hop withdrawal ends (`algebra.rs`, `the_floor_refuses_every_dead_hop`); a +claim's path in Rust grows by exactly the relay that took it +(`a_claim_step_never_improves_a_claim`). ## What this does not give - **The rule as it runs.** The theorem is for ties broken by one fixed order. - The prototype puts the next hop in use ahead of the shorter path and the + The router puts the next hop in use ahead of the shorter path and the neighbour, so which of two equal routes a node settles on depends on which came first, and the stable state is not unique. The argument that it still settles is on paper and tested, not mechanized (below). +- **The router's state machine.** The binding runs the functions that rank, + extend, and refuse one route or claim, not the state around them: which offers + a node keeps, the floors and drains it learns, the revisions that order a + node's claims, the readers' debounce, and what `route` and `adopt` refuse as + malformed, which closes the session. That a node feeds those functions the + latest offer from each neighbour is argued on paper (below). - **Loop freedom at every instant.** Only the fixed point is loop-free. [Requests](https://github.com/moq-dev/moq/pull/8881) name their origin node and fail closed instead. @@ -116,32 +163,43 @@ never improves a claim in the real router (`a_grant_never_improves_a_claim`). - **Liveness under churn that never stops.** Convergence needs each epoch to last long enough. - **The chain where a claim stays inside a domain.** The claim instance's path - names every node that took the claim, and each refuses a claim naming it. + names every relay that took the claim, and each refuses a claim naming it. Rust's chain names the relays a claim entered or left a routing domain by: the announcing relay, then each grant's exporter and adopter, a relay that adopts across one grant and exports across the next once, which is that path - without the steps from a node to itself. A relay across a grant refuses a - claim whose chain, with it appended, names a relay twice, so it refuses what - the algebra refuses at it as adopter and at its exporter. Inside a domain no - node checks the chain: a claim that left a domain and came back by a third - relay is announced there, as the algebra allows, and a node of that domain - the chain names, which the algebra has refuse it, still ranks it below the - claim it echoes, and the relay across the next grant it would leave by - refuses it. -- **The neighbour key.** The proof orders equal routes by the neighbour's relay - and then its start. The prototype orders them by its simulation's node index, - which equals the relay. The production router must order them by the - neighbour's Node ID, or the binding must supply the equivalent key. + without the steps within a domain. A relay across a grant refuses a claim + whose chain, with it appended, names a relay twice, so it refuses what the + algebra refuses at it as adopter and at its exporter. Inside a domain no node + checks the chain: a claim that left a domain and came back by a third relay is + announced there, as the algebra allows, and a node of that domain the chain + names, which the algebra has refuse it, still ranks it below the claim it + echoes, and the relay across the next grant it would leave by refuses it. The + binding samples no such step. +- **Which claims a node knows.** The best precedence a node knows of, reachable + or not, is a label on its links, fixed within an epoch, like `claimed`. It is + not: a claim no route reaches stays known while any neighbour still offers its + announcer, and a claim told unavailable across a grant is taken only as news of + one the giver gave before. An unavailable claim is otherwise outside the + algebra, which has it invalid. +- **Two sessions to one neighbour.** The algebra has one link per pair of nodes. + The router can hold two sessions to one Node ID, and breaks a tie between them + by the session's key, after everything the algebra orders by. +- **A saturated claim cost.** A claim's cost saturates at the metric, so a step + past it adds nothing, where the algebra's always adds. The binding samples + costs far below it. +- **An application's claims.** A router that does not forward names itself in no + chain, so its own claims' paths are a step shorter than a relay's. The binding + samples relays only. - **A preference for the unmarked side at any cost.** Unmarked beats marked only - at equal draining, priority, and cost: a strictly cheaper marked route still - wins. Priority outranks cost, so an operator who wants the unmarked side + at equal draining, priority, and cost: a strictly cheaper marked route or claim + still wins. Priority outranks cost, so an operator who wants the unmarked side preferred raises its priority. -- **Which relays announce.** Under `claimed` a relay offers a route to itself - from its first claim on, for good, and whether a relay with no endpoint ever - gets a claim across a scoped grant can depend on arrival order. So the set of - route origins depends on history. The proof takes it as a link label fixed - within an epoch. `sticky.rs`'s `whether_a_relay_announces_hangs_on_arrival_order` - shows a relay that keeps a route to itself with no claim behind it. +- **Which relays announce.** A relay offers a route to itself from its first + claim on, for good, and whether a relay with no endpoint ever gets a claim + across a scoped grant can depend on arrival order. So the set of route origins + depends on history. The proof takes it as a link label fixed within an epoch. + `sticky.rs`'s `whether_a_relay_announces_hangs_on_arrival_order` shows a relay + that keeps a route to itself with no claim behind it. ## On paper @@ -152,8 +210,8 @@ that fixed point. **The hypotheses hold.** A floor holds a session only once the node learned it closed, from its own session ending or from a neighbour naming it. Sessions -between a pair of relays are numbered upward within a start, and with `epoch` a -later start orders above every session of an earlier one, so no live session +between a pair of relays are numbered upward within a start, and a later start +orders above every session of an earlier one, so no live session sits at or below a floor (`FloorsClosed`). A relay that sends GOAWAY sends it on every session, and a node is named draining only by a neighbour that heard it (`DrainNamed`). @@ -165,11 +223,10 @@ the fixed point is too. **A function of the latest heard.** A node keeps the latest offer from each neighbour for each origin node, delivered in order on one stream, and picks with -`candidates` and `order` over those alone. A withdrawal is the invalid route. +`Router::usable` and `order` over those alone. A withdrawal is the invalid route. In-order delivery is a special case of the library's data-flow function. -**Dead hops and ended routes.** With `floor`, every route a dead-hop -withdrawal would end names a session the floor holds closed, so the floor +**Dead hops and ended routes.** Every route a dead-hop withdrawal would end names a session the floor holds closed, so the floor already refuses it (`the_floor_refuses_every_dead_hop`). A route a neighbour ended stays invalid until that neighbour's next offer, which is the iteration's own withdrawal. @@ -181,9 +238,9 @@ use. The flag only turns on (until a restart, which is a new node), so within an epoch it is a fixed label. **Claims after routes.** A claim's rank is the route to its announcer joined -with the claim's own drain, priority, and cost. Once routes settle, the claims' -iteration runs over a fixed route state and is itself an increasing algebra, so -it settles too. +with the claim's own drain, priority, and cost (`Claim::over`). Once routes +settle, the claims' iteration runs over a fixed route state and is itself an +increasing algebra (`Claim`), so it settles too. **Loop-free trees at the fixed point.** At the fixed point a node's route is its next hop's route extended by one link, so the path shortens by one at each next @@ -199,7 +256,7 @@ preference among couplets of equal weight, and his proof's fourth case uses that the couplet a node chose was preferred to every couplet it could choose then. Staying on the next hop in use prefers by state instead. The argument here rests only on the rank R = (draining, priority, cost) being strictly increasing: every -port costs at least 1 (`Router::connect` asserts it) and drain and priority +port to a forwarding node costs at least 1 (`Router::connect` refuses a free one) and drain and priority never improve. Order the finitely many values of R a path of at most 32 hops can take. Suppose that from some time on, no node's selection of rank below r changes. Once every message sent before then is delivered, every candidate of @@ -214,23 +271,14 @@ rank at most r settle too, and by induction all do. Which route a node settles on can differ, but not its rank or mark. A candidate a path-dependent filter refuses at node i is one whose path names i, and then i already holds that path's prefix at a strictly lower rank; or one past the hop -limit; or one through a floored session, and no settled path crosses one. So +limit; or one through a floored session, and no settled path crosses one; or one +naming another start of i's relay, every session of which closed, so the floor +refuses it too once the epoch's news is delivered. So every node settles on the rank and mark the fixed order gives it, except where a neighbour's longer path meets the 32-hop limit, and only the next hop varies. `sticky.rs` checks this: 150 random networks, through churn, each settled twice -from cold in two delivery orders, differ in next hop at 29 of 2,272 routes and +from cold in two delivery orders, differ in next hop at 29 of 2,282 routes and never in rank, mark, or reachability. With the mark below the next hop in use -the same sweep differed in the mark at 19, and +the same sweep differed in the mark at 20, and `an_equal_route_in_use_never_leaves_a_neighbour_without_one` shows the neighbour that order left without a route. - -## Moving the binding to the production router - -The tests bind to the prototype, which the router quest -([router](https://github.com/moq-dev/moq/pull/8901)) replaces with `route/relay.rs`. When it -lands, point `algebra.rs` and `sticky.rs` at the router's equivalents of -`Offer::own`, `Offer::onward`, `Here::arrive`, `order`, and `candidates`, -keeping them one function each that the router itself calls. Instantiate -`Route` with the router's neighbour key in place of `Sim`'s `relay` and -`start`, or order neighbours by Node ID and change `Route`'s path order to -match. Then regenerate `Vectors.agda` and run `just test route-proof`. diff --git a/rs/moq-net/verify/route-algebra/Route.agda b/rs/moq-net/verify/route-algebra/Route.agda index cd083dc333c..70f30f4d5f9 100644 --- a/rs/moq-net/verify/route-algebra/Route.agda +++ b/rs/moq-net/verify/route-algebra/Route.agda @@ -1,11 +1,16 @@ -------------------------------------------------------------------------------- --- Routes between forwarding nodes, as the multicast epic's rule ranks and --- extends them (`rs/moq-net/src/route/tests/multi.rs`, every `Tune` the epic --- picked on: floor, epoch, batch, drain, claimed). +-- Routes between forwarding nodes, as `route::relay::Router` ranks and extends +-- them (`rs/moq-net/src/route/relay.rs`). -- --- A node is one start of one relay: a restart is a new node, as a restarted --- relay names itself afresh. `relay` and `start` read the two back from a node, --- since the floor files a closed session by relays and orders it by start. +-- A node is a Node ID: one start of one relay, a restart being a new node as a +-- restarted relay names itself afresh, and each start's marked identity, which +-- announces what the node took over a marked link. `relay`, `start`, and `mark` +-- read the three back from a node: the floor files a closed session by relays and +-- orders it by start, a node refuses a path naming another start of its relay, +-- and equal routes order by the neighbour's Node ID. +-- +-- A node's marked identity is a node whose one link is from the node itself: up, +-- free, marked, at session 0, so its route there is the node's marked route. -- -- A route at node i is what i would offer: its path names i first, then i's next -- hop, and so on to the forwarding node it leads to. `extra` carries, beside each @@ -15,7 +20,7 @@ open import Data.Bool.Base using (Bool; true; false; _∨_; _∧_; not; if_then_else_) open import Data.List.Base using (List; []; _∷_; map; any; zip; null; length) -open import Data.Nat.Base using (ℕ; suc; _≡ᵇ_; _<ᵇ_; _≤ᵇ_) +open import Data.Nat.Base using (ℕ; suc; _+_; _≡ᵇ_; _<ᵇ_; _≤ᵇ_) open import Data.Product.Base using (_×_; _,_; proj₁; proj₂) open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong) @@ -23,15 +28,13 @@ open import RoutingLib.Routing.Basics.Path.Uncertified using (Path; Edge) open import Order -module Route - (relay start : ℕ → ℕ) - (relay-start-injective : ∀ {m n} → relay m ≡ relay n → start m ≡ start n → m ≡ n) - where +module Route (relay start mark : ℕ → ℕ) where -import Data.Bool.Properties as Bool open import Data.List.Properties using (map-injective) open import Data.List.Relation.Binary.Lex.Core using (base; halt) open import Data.Product.Properties using (,-injectiveˡ; ,-injectiveʳ) +open import Data.Unit.Base using (⊤; tt) +import Data.Unit.Properties as Unit -- The longest path a node takes, counting the node it leads to (`MAX_HOPS`). max-hops : ℕ @@ -54,21 +57,27 @@ e₀-least : ∀ e → Ordered._≤_ OE e₀ e e₀-least [] = base _ e₀-least (_ ∷ _) = halt --- Among equal ranks and lengths, by the neighbour: its relay, then its start. --- No two candidates at one node share a neighbour, so the rest of the path --- never decides between them. +-- Among equal ranks and lengths, by the neighbour's Node ID: its relay, then its +-- start, then unmarked first, as `NodeId` orders. No two candidates at one node +-- share a neighbour, so the rest of the path never decides between them. OP : Ordered Path -OP = keyed (map neighbour) (map-injective neighbour-injective) (list (lex nat (lex nat nat))) +OP = keyed (map neighbour) (map-injective neighbour-injective) (list (lex nat (lex nat (lex nat (lex nat nat))))) where - neighbour : Edge → ℕ × ℕ × ℕ - neighbour (a , b) = a , relay b , start b + neighbour : Edge → ℕ × ℕ × ℕ × ℕ × ℕ + neighbour (a , b) = a , relay b , start b , mark b , b neighbour-injective : ∀ {x y} → neighbour x ≡ neighbour y → x ≡ y neighbour-injective {a , b} {c , d} eq with ,-injectiveˡ eq - ... | refl = cong (a ,_) (relay-start-injective - (,-injectiveˡ (,-injectiveʳ eq)) (,-injectiveʳ (,-injectiveʳ eq))) + ... | refl = cong (a ,_) (,-injectiveʳ (,-injectiveʳ (,-injectiveʳ (,-injectiveʳ eq)))) + +-- Nothing leads a route's rank. +OC : Ordered ⊤ +OC = record { _≤_ = _≡_ ; isDecTotalOrder = Unit.≡-isDecTotalOrder } + +OT : Ordered (Path × Extra) +OT = lex OP OE -open import Increasing OE e₀ e₀-least OP public +open import Increasing OC tt (λ _ → refl) e₀ OT (λ e → lex-≤ OP OE (Ordered.refl OP) λ _ → e₀-least e) public ------------------------------------------------------------------------ -- The link @@ -110,16 +119,31 @@ closed fs ((a , b) , s) = any at-or-below fs at-or-below (floor n f st se) = (relay a ≡ᵇ n) ∧ (relay b ≡ᵇ f) ∧ ((start a <ᵇ st) ∨ ((start a ≡ᵇ st) ∧ (s ≤ᵇ se))) +-- The largest cost a route carries (`Metric`). +metric : ℕ +metric = 18446744073709551615 + +-- Whether a path at j names another start of i's relay. +elsewhere : Edge → Path → Bool +elsewhere (i , j) p = any other (j ∷ map proj₂ p) + where + other : ℕ → Bool + other n = (relay n ≡ᵇ relay i) ∧ not (start n ≡ᵇ start i) + -- A link refuses a route when it is down, when the route is the neighbour's -- route to itself and the neighbour announces no claim, when the route crossed a -- marked link and this one is marked at the neighbour, when the path would grow --- past `max-hops`, or when it names a session the receiver knows closed. +-- past `max-hops`, when the cost would pass the metric, when the path names +-- another start of the receiver's relay, or when it names a session the receiver +-- knows closed. refuses : Link → Edge → Valid → Bool -refuses f _ v = +refuses f e v = not (L.up f) ∨ (null (path v) ∧ not (L.claimed f)) ∨ (marked v ∧ L.marked-there f) ∨ (max-hops ≤ᵇ suc (length (path v))) + ∨ (metric <ᵇ L.cost f + cost v) + ∨ elsewhere e (path v) ∨ any (closed (L.floors f)) (zip (path v) (extra v)) -- The receiver ranks a route draining when it names a node known draining. @@ -130,6 +154,8 @@ policy : Policy policy = record { Link = Link ; down = link false 0 0 false [] [] false false false 0 + ; rise = λ _ c → c + ; rise-≥ = λ _ _ → refl ; cost = L.cost ; penalty = L.penalty ; drains = L.drains @@ -137,7 +163,7 @@ policy = record ; marked = L.marked-here ; refuses = refuses ; down-refuses = λ _ _ → refl - ; tag = λ f ss → L.session f ∷ ss + ; tag = λ f _ v → L.session f ∷ extra v } open Rule policy public diff --git a/rs/moq-net/verify/route-algebra/Sim.agda b/rs/moq-net/verify/route-algebra/Sim.agda deleted file mode 100644 index 5514f5cc59f..00000000000 --- a/rs/moq-net/verify/route-algebra/Sim.agda +++ /dev/null @@ -1,20 +0,0 @@ --------------------------------------------------------------------------------- --- The route rule as the Rust prototype runs it: a node is named --- 1000 × start + relay, as `hop` in `rs/moq-net/src/route/tests/mod.rs` names it. --------------------------------------------------------------------------------- - -module Sim where - -open import Data.Nat.Base using (ℕ; _%_; _/_; _+_; _*_) -open import Data.Nat.DivMod using (m≡m%n+[m/n]*n) -open import Relation.Binary.PropositionalEquality using (_≡_; cong₂; trans; sym) - -relay start : ℕ → ℕ -relay n = n % 1000 -start n = n / 1000 - -relay-start-injective : ∀ {m n} → relay m ≡ relay n → start m ≡ start n → m ≡ n -relay-start-injective {m} {n} r s = trans (m≡m%n+[m/n]*n m 1000) - (trans (cong₂ (λ a b → a + b * 1000) r s) (sym (m≡m%n+[m/n]*n n 1000))) - -open import Route relay start relay-start-injective public diff --git a/rs/moq-net/verify/route-algebra/Vectors.agda b/rs/moq-net/verify/route-algebra/Vectors.agda index b1a6ccd3708..f13300c354d 100644 --- a/rs/moq-net/verify/route-algebra/Vectors.agda +++ b/rs/moq-net/verify/route-algebra/Vectors.agda @@ -1,1421 +1,1490 @@ -- Generated by `rs/moq-net/src/route/tests/algebra.rs` (`ROUTE_VECTORS=write`); do not edit. --- Each case is a result the Rust prototype computed, which the algebra must compute too. +-- Each case is a result `route::relay::Router` computed, which the algebra must compute too. module Vectors where open import Data.Bool.Base using (true; false) open import Data.List.Base using ([]; _∷_) open import Data.Product.Base using (_,_) +open import Data.Unit.Base using (tt) open import Relation.Binary.PropositionalEquality using (_≡_; refl) -open import Sim +open import Named -_ : extend (link true 2 0 false (1006 ∷ []) ([]) false false true 1) (1000 , 1003) (valid (route true 128 2 false ((1003 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2002) ∷ []) (1 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route true 128 4 false ((1000 , 1003) ∷ (1003 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2002) ∷ []) (1 ∷ 1 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 0 0 false (4003 ∷ []) ([]) true false true 0) (2000 , 3000) (valid (route tt false 0 0 false [] [])) + ≡ valid (route tt false 0 0 true ((2000 , 3000) ∷ []) (0 ∷ [])) _ = refl -_ : extend (link true 3 127 true (1002 ∷ []) (floor 0 2 1 2 ∷ floor 2 0 1 2 ∷ []) true false false 2) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) +_ : extend (link true 0 0 false ([]) (floor 3 2 1 2 ∷ floor 3 3 2 0 ∷ []) true false false 0) (2000 , 3000) (valid (route tt false 0 0 false [] [])) ≡ invalid _ = refl -_ : extend (link true 1 255 true (1001 ∷ []) ([]) true false true 2) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 255 1 true ((1000 , 2004) ∷ []) (2 ∷ [])) +_ : extend (link true 2 255 false (2002 ∷ []) ([]) false true true 3) (2000 , 2006) (valid (route tt false 122 10 false ((2006 , 2000) ∷ (2000 , 2001) ∷ (2001 , 4003) ∷ (4003 , 2004) ∷ []) (2 ∷ 3 ∷ 1 ∷ 1 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 1 128 true (1005 ∷ []) (floor 5 5 1 1 ∷ []) false true false 2) (1000 , 1001) (valid (route true 0 10 false ((1001 , 1004) ∷ (1004 , 1000) ∷ (1000 , 1002) ∷ []) (1 ∷ 2 ∷ 1 ∷ []))) +_ : extend (link true 1 122 false (2002 ∷ []) (floor 4 4 2 2 ∷ []) true true true 2) (2000 , 4001) (valid (route tt false 255 10 false ((4001 , 2000) ∷ (2000 , 2002) ∷ (2002 , 4006) ∷ []) (3 ∷ 1 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 0 false (1004 ∷ []) (floor 2 3 2 3 ∷ []) false false true 3) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 0 3 false ((1000 , 1003) ∷ []) (3 ∷ [])) +_ : extend (link true 1 127 true ([]) ([]) true false true 3) (2000 , 2002) (valid (route tt false 0 0 true ((2002 , 3002) ∷ []) (0 ∷ []))) + ≡ valid (route tt true 127 1 true ((2000 , 2002) ∷ (2002 , 3002) ∷ []) (3 ∷ 0 ∷ [])) +_ = refl + +_ : extend (link true 2 0 false (2002 ∷ []) ([]) true true false 2) (2000 , 4002) (valid (route tt false 128 3 false ((4002 , 4005) ∷ (4005 , 4006) ∷ (4006 , 2003) ∷ []) (2 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route tt false 128 5 true ((2000 , 4002) ∷ (4002 , 4005) ∷ (4005 , 4006) ∷ (4006 , 2003) ∷ []) (2 ∷ 2 ∷ 2 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 1 0 false (2006 ∷ []) ([]) false false true 3) (2000 , 2003) (valid (route tt false 0 0 true ((2003 , 3003) ∷ []) (0 ∷ []))) + ≡ valid (route tt false 0 1 true ((2000 , 2003) ∷ (2003 , 3003) ∷ []) (3 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 1 128 false (1004 ∷ []) (floor 3 1 1 1 ∷ floor 6 1 1 3 ∷ floor 6 4 1 1 ∷ []) false false true 1) (1000 , 1005) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 128 1 false ((1000 , 1005) ∷ []) (1 ∷ [])) +_ : extend (link true 1 0 false ([]) (floor 1 1 1 1 ∷ floor 4 0 2 0 ∷ floor 6 1 2 0 ∷ []) false true true 2) (2000 , 4005) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 1 false ((2000 , 4005) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 1 128 false (2002 ∷ []) ([]) false false true 2) (1000 , 1006) (valid (route false 128 10 false ((1006 , 1000) ∷ (1000 , 1001) ∷ []) (2 ∷ 2 ∷ []))) +_ : extend (link true 1 127 false ([]) ([]) false false true 3) (2000 , 4005) (valid (route tt false 127 3 false ((4005 , 4000) ∷ (4000 , 4001) ∷ (4001 , 2003) ∷ []) (2 ∷ 2 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 2 122 false (2001 ∷ 2005 ∷ []) ([]) false true true 2) (1000 , 2005) (valid (route true 122 6 false ((2005 , 1004) ∷ (1004 , 1003) ∷ []) (1 ∷ 3 ∷ []))) - ≡ valid (route true 122 8 false ((1000 , 2005) ∷ (2005 , 1004) ∷ (1004 , 1003) ∷ []) (2 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 4 128 false (2006 ∷ []) ([]) true false true 3) (2000 , 4001) (valid (route tt false 0 7 true ((4001 , 2004) ∷ (2004 , 4002) ∷ (4002 , 4005) ∷ []) (3 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route tt false 128 11 true ((2000 , 4001) ∷ (4001 , 2004) ∷ (2004 , 4002) ∷ (4002 , 4005) ∷ []) (3 ∷ 3 ∷ 2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 122 false (2006 ∷ []) (floor 0 1 1 1 ∷ []) false false false 3) (1000 , 1002) (valid (route true 128 10 false ((1002 , 2004) ∷ []) (1 ∷ []))) - ≡ valid (route true 128 11 false ((1000 , 1002) ∷ (1002 , 2004) ∷ []) (3 ∷ 1 ∷ [])) +_ : extend (link true 3 128 false ([]) (floor 1 1 1 3 ∷ floor 3 0 2 3 ∷ floor 6 5 2 3 ∷ []) true true false 2) (2000 , 2004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ invalid _ = refl -_ : extend (link true 4 128 false (1004 ∷ []) ([]) true false true 3) (1000 , 2001) (valid (route false 128 1 false ((2001 , 2005) ∷ (2005 , 1000) ∷ (1000 , 1006) ∷ []) (3 ∷ 2 ∷ 3 ∷ []))) +_ : extend (link true 4 127 false ([]) ([]) true false false 3) (2000 , 2003) (valid (route tt false 128 8 true ((2003 , 4000) ∷ []) (2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 255 true (1001 ∷ 1003 ∷ []) ([]) true true true 1) (1000 , 2002) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 255 3 true ((1000 , 2002) ∷ []) (1 ∷ [])) +_ : extend (link true 1 128 false ([]) (floor 1 1 2 2 ∷ floor 5 4 2 3 ∷ []) false false true 2) (2000 , 2004) (valid (route tt true 255 3 false ((2004 , 4005) ∷ (4005 , 4001) ∷ (4001 , 2003) ∷ []) (3 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route tt true 255 4 false ((2000 , 2004) ∷ (2004 , 4005) ∷ (4005 , 4001) ∷ (4001 , 2003) ∷ []) (2 ∷ 3 ∷ 1 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 4 255 false (4006 ∷ []) (floor 2 4 2 2 ∷ []) false false true 2) (2000 , 2001) (valid (route tt false 0 1 true ((2001 , 4002) ∷ (4002 , 4004) ∷ []) (1 ∷ 3 ∷ []))) + ≡ valid (route tt false 255 5 true ((2000 , 2001) ∷ (2001 , 4002) ∷ (4002 , 4004) ∷ []) (2 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 127 true (1004 ∷ []) (floor 1 5 1 3 ∷ []) false false true 1) (1000 , 1004) (valid (route true 122 0 true ((1004 , 1015) ∷ (1015 , 2021) ∷ (2021 , 1008) ∷ (1008 , 2037) ∷ (2037 , 2020) ∷ (2020 , 1040) ∷ (1040 , 1025) ∷ (1025 , 2028) ∷ (2028 , 1024) ∷ (1024 , 1013) ∷ (1013 , 2001) ∷ (2001 , 2010) ∷ (2010 , 2014) ∷ (2014 , 1032) ∷ (1032 , 1012) ∷ (1012 , 1038) ∷ (1038 , 1017) ∷ (1017 , 2007) ∷ (2007 , 2022) ∷ (2022 , 1034) ∷ (1034 , 2031) ∷ (2031 , 1009) ∷ (1009 , 1019) ∷ (1019 , 1026) ∷ (1026 , 1005) ∷ (1005 , 1027) ∷ (1027 , 1006) ∷ (1006 , 1036) ∷ (1036 , 1016) ∷ (1016 , 1002) ∷ (1002 , 1003) ∷ []) (1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ []))) +_ : extend (link true 4 0 true (2002 ∷ 2006 ∷ []) (floor 4 5 1 2 ∷ []) false true true 2) (2000 , 4002) (valid (route tt false 127 11 false ((4002 , 4003) ∷ (4003 , 4000) ∷ (4000 , 4001) ∷ (4001 , 5001) ∷ []) (1 ∷ 3 ∷ 1 ∷ 0 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 122 true (1006 ∷ []) ([]) false true false 2) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) +_ : extend (link true 1 127 true (4001 ∷ []) (floor 3 5 1 0 ∷ floor 5 6 2 0 ∷ []) false false true 2) (2000 , 4004) (valid (route tt true 122 0 false ((4004 , 4006) ∷ (4006 , 2000) ∷ (2000 , 2001) ∷ []) (2 ∷ 2 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 122 false (2002 ∷ []) ([]) false true false 1) (1000 , 1004) (valid (route false 0 11 false ((1004 , 2005) ∷ (2005 , 1003) ∷ []) (3 ∷ 2 ∷ []))) - ≡ valid (route false 122 14 false ((1000 , 1004) ∷ (1004 , 2005) ∷ (2005 , 1003) ∷ []) (1 ∷ 3 ∷ 2 ∷ [])) +_ : extend (link true 1 127 true (4006 ∷ []) (floor 3 6 1 2 ∷ floor 5 2 1 1 ∷ floor 6 2 1 0 ∷ []) true false true 3) (2000 , 2003) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 127 1 true ((2000 , 2003) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 4 122 true (1001 ∷ 2005 ∷ []) ([]) false false true 1) (1000 , 2003) (valid (route true 127 3 true ((2003 , 1005) ∷ (1005 , 2001) ∷ (2001 , 1003) ∷ (1003 , 2006) ∷ []) (3 ∷ 3 ∷ 2 ∷ 3 ∷ []))) - ≡ valid (route true 127 7 true ((1000 , 2003) ∷ (2003 , 1005) ∷ (1005 , 2001) ∷ (2001 , 1003) ∷ (1003 , 2006) ∷ []) (1 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 2 122 false ([]) (floor 1 4 1 1 ∷ floor 3 6 2 3 ∷ []) true true false 3) (2000 , 4004) (valid (route tt false 127 10 false ((4004 , 2006) ∷ []) (3 ∷ []))) + ≡ valid (route tt false 127 12 true ((2000 , 4004) ∷ (4004 , 2006) ∷ []) (3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 0 false (1006 ∷ 2003 ∷ []) (floor 6 3 1 1 ∷ []) true false true 1) (1000 , 2002) (valid (route false 122 1 false ((2002 , 2003) ∷ []) (3 ∷ []))) - ≡ valid (route true 122 5 true ((1000 , 2002) ∷ (2002 , 2003) ∷ []) (1 ∷ 3 ∷ [])) +_ : extend (link true 1 127 false (4003 ∷ []) ([]) true false true 1) (2000 , 4001) (valid (route tt false 128 9 false ((4001 , 2002) ∷ []) (1 ∷ []))) + ≡ valid (route tt false 128 10 true ((2000 , 4001) ∷ (4001 , 2002) ∷ []) (1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 3 127 true (1005 ∷ 1006 ∷ []) (floor 3 1 2 0 ∷ []) false false true 3) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 127 3 false ((1000 , 1003) ∷ []) (3 ∷ [])) +_ : extend (link true 3 127 true ([]) (floor 3 4 2 3 ∷ []) false false true 3) (2000 , 2004) (valid (route tt false 255 8 false ((2004 , 2005) ∷ (2005 , 2006) ∷ []) (3 ∷ 3 ∷ []))) + ≡ valid (route tt true 255 11 false ((2000 , 2004) ∷ (2004 , 2005) ∷ (2005 , 2006) ∷ []) (3 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 0 false ([]) (floor 5 6 1 0 ∷ []) false false true 3) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 0 3 false ((1000 , 2003) ∷ []) (3 ∷ [])) +_ : extend (link true 4 122 false ([]) (floor 5 6 1 0 ∷ []) false false true 1) (2000 , 2004) (valid (route tt false 255 3 true ((2004 , 4006) ∷ (4006 , 4005) ∷ []) (1 ∷ 2 ∷ []))) + ≡ valid (route tt false 255 7 true ((2000 , 2004) ∷ (2004 , 4006) ∷ (4006 , 4005) ∷ []) (1 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 4 255 false ([]) (floor 4 3 1 3 ∷ floor 5 2 1 1 ∷ floor 6 5 2 3 ∷ []) true true true 3) (1000 , 1003) (valid (route false 127 1 true ((1003 , 1001) ∷ (1001 , 1006) ∷ (1006 , 1000) ∷ (1000 , 1004) ∷ []) (2 ∷ 2 ∷ 2 ∷ 3 ∷ []))) - ≡ invalid +_ : extend (link true 4 128 false (4002 ∷ 4005 ∷ []) ([]) false false true 2) (2000 , 4003) (valid (route tt false 0 0 true ((4003 , 5003) ∷ []) (0 ∷ []))) + ≡ valid (route tt false 128 4 true ((2000 , 4003) ∷ (4003 , 5003) ∷ []) (2 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 3 127 true (1001 ∷ []) (floor 0 5 1 3 ∷ []) false false true 2) (1000 , 2003) (valid (route true 0 11 false ((2003 , 1000) ∷ []) (2 ∷ []))) +_ : extend (link true 3 255 true (2004 ∷ []) (floor 1 4 1 3 ∷ floor 2 6 2 2 ∷ floor 6 0 1 0 ∷ []) false false true 3) (2000 , 4001) (valid (route tt false 127 0 false ((4001 , 4000) ∷ []) (3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 122 true (2001 ∷ []) (floor 1 2 1 1 ∷ []) false true true 2) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 122 4 false ((1000 , 1006) ∷ []) (2 ∷ [])) +_ : extend (link true 2 122 true (2002 ∷ []) ([]) false false true 2) (2000 , 2005) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 122 2 false ((2000 , 2005) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 3 255 true ([]) (floor 3 4 2 2 ∷ []) true false false 3) (1000 , 1001) (valid (route false 0 0 false ([]) ([]))) - ≡ invalid +_ : extend (link true 3 127 false ([]) (floor 1 4 2 0 ∷ floor 3 1 2 1 ∷ floor 5 4 1 0 ∷ []) false false true 3) (2000 , 4001) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 127 3 false ((2000 , 4001) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 2 0 false (1004 ∷ 2005 ∷ []) ([]) false false true 1) (1000 , 2004) (valid (route false 0 0 false ((2004 , 1004) ∷ (1004 , 2001) ∷ (2001 , 2005) ∷ (2005 , 1002) ∷ []) (1 ∷ 3 ∷ 3 ∷ 2 ∷ []))) - ≡ valid (route true 0 2 false ((1000 , 2004) ∷ (2004 , 1004) ∷ (1004 , 2001) ∷ (2001 , 2005) ∷ (2005 , 1002) ∷ []) (1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ [])) +_ : extend (link true 2 0 false (2006 ∷ []) (floor 4 2 2 2 ∷ []) false true true 2) (2000 , 4004) (valid (route tt false 0 0 true ((4004 , 5004) ∷ []) (0 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 3 122 false (2004 ∷ []) (floor 2 5 1 2 ∷ floor 4 1 2 3 ∷ []) false false true 1) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 122 3 false ((1000 , 2001) ∷ []) (1 ∷ [])) +_ : extend (link true 4 255 true ([]) (floor 6 2 2 1 ∷ []) true false true 1) (2000 , 2001) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 255 4 true ((2000 , 2001) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 128 true ([]) (floor 1 1 2 1 ∷ floor 1 5 1 0 ∷ []) true true false 1) (1000 , 2001) (valid (route false 122 3 false ((2001 , 2002) ∷ (2002 , 2006) ∷ (2006 , 1004) ∷ (1004 , 1000) ∷ []) (3 ∷ 2 ∷ 3 ∷ 1 ∷ []))) +_ : extend (link true 1 255 false (2004 ∷ []) (floor 4 4 1 2 ∷ []) false true true 2) (2000 , 2006) (valid (route tt false 255 0 false ((2006 , 4000) ∷ (4000 , 4004) ∷ (4004 , 2003) ∷ []) (3 ∷ 3 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 0 false (1004 ∷ []) ([]) true false true 3) (1000 , 2006) (valid (route false 122 3 true ((2006 , 1003) ∷ (1003 , 1000) ∷ []) (3 ∷ 3 ∷ []))) +_ : extend (link true 2 255 false ([]) (floor 2 2 1 2 ∷ floor 6 6 1 0 ∷ []) false false false 2) (2000 , 4001) (valid (route tt false 0 1 false ((4001 , 2000) ∷ (2000 , 4002) ∷ (4002 , 4004) ∷ []) (2 ∷ 1 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 128 true (2002 ∷ []) (floor 2 1 1 0 ∷ []) false true true 2) (1000 , 2005) (valid (route true 255 9 true ((2005 , 1006) ∷ (1006 , 2003) ∷ (2003 , 1001) ∷ []) (2 ∷ 1 ∷ 3 ∷ []))) - ≡ invalid +_ : extend (link true 1 122 false (4004 ∷ []) (floor 3 2 2 3 ∷ floor 4 2 2 3 ∷ []) false false true 1) (2000 , 2002) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 122 1 false ((2000 , 2002) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 1 127 false ([]) (floor 5 2 1 1 ∷ []) true false true 1) (1000 , 1004) (valid (route false 255 10 false ((1004 , 1001) ∷ (1001 , 2006) ∷ (2006 , 1005) ∷ (1005 , 2002) ∷ []) (2 ∷ 2 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route false 255 11 true ((1000 , 1004) ∷ (1004 , 1001) ∷ (1001 , 2006) ∷ (2006 , 1005) ∷ (1005 , 2002) ∷ []) (1 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 2 0 false ([]) ([]) true false false 2) (2000 , 2006) (valid (route tt false 122 4 false ((2006 , 4002) ∷ (4002 , 4003) ∷ (4003 , 4001) ∷ []) (3 ∷ 1 ∷ 1 ∷ []))) + ≡ valid (route tt false 122 6 true ((2000 , 2006) ∷ (2006 , 4002) ∷ (4002 , 4003) ∷ (4003 , 4001) ∷ []) (2 ∷ 3 ∷ 1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 0 false (1004 ∷ 2003 ∷ []) (floor 1 2 2 0 ∷ floor 3 6 2 3 ∷ []) true false true 2) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 0 4 true ((1000 , 2003) ∷ []) (2 ∷ [])) +_ : extend (link true 4 127 true ([]) (floor 4 5 2 2 ∷ []) false false true 3) (2000 , 2002) (valid (route tt false 127 1 false ((2002 , 4006) ∷ []) (3 ∷ []))) + ≡ valid (route tt true 127 5 false ((2000 , 2002) ∷ (2002 , 4006) ∷ []) (3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 127 false (1003 ∷ 1006 ∷ []) (floor 0 4 2 2 ∷ floor 6 1 1 1 ∷ []) false true true 1) (1000 , 1002) (valid (route false 127 11 false ((1002 , 2006) ∷ (2006 , 1000) ∷ (1000 , 2004) ∷ []) (1 ∷ 2 ∷ 1 ∷ []))) +_ : extend (link true 4 0 false (2005 ∷ []) (floor 5 4 2 2 ∷ []) false true true 1) (2000 , 4003) (valid (route tt false 0 0 true ((4003 , 5003) ∷ []) (0 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 255 false (1003 ∷ 1006 ∷ []) (floor 0 2 1 2 ∷ floor 4 4 2 1 ∷ floor 5 2 1 3 ∷ []) false false true 2) (1000 , 2005) (valid (route false 128 10 true ((2005 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1000) ∷ (1000 , 2002) ∷ []) (3 ∷ 2 ∷ 3 ∷ 1 ∷ []))) - ≡ invalid +_ : extend (link true 3 127 true ([]) ([]) false false true 2) (2000 , 2006) (valid (route tt false 127 3 true ((2006 , 2003) ∷ (2003 , 2004) ∷ []) (1 ∷ 1 ∷ []))) + ≡ valid (route tt true 127 6 true ((2000 , 2006) ∷ (2006 , 2003) ∷ (2003 , 2004) ∷ []) (2 ∷ 1 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 1 0 false (2006 ∷ []) (floor 4 4 2 1 ∷ floor 6 1 1 1 ∷ []) false false true 2) (2000 , 4006) (valid (route tt false 128 1 true ((4006 , 4004) ∷ (4004 , 2003) ∷ (2003 , 4002) ∷ (4002 , 2001) ∷ []) (1 ∷ 3 ∷ 3 ∷ 1 ∷ []))) + ≡ valid (route tt false 128 2 true ((2000 , 4006) ∷ (4006 , 4004) ∷ (4004 , 2003) ∷ (2003 , 4002) ∷ (4002 , 2001) ∷ []) (2 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 255 false (2006 ∷ []) (floor 1 5 2 3 ∷ []) false true true 2) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 255 2 false ((1000 , 2001) ∷ []) (2 ∷ [])) +_ : extend (link true 4 0 false (4002 ∷ 4005 ∷ []) (floor 1 2 1 3 ∷ floor 5 5 1 2 ∷ floor 6 4 1 3 ∷ []) true true true 1) (2000 , 4005) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 0 4 true ((2000 , 4005) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 0 false (1006 ∷ []) ([]) false true true 1) (1000 , 2001) (valid (route false 0 3 false ((2001 , 2006) ∷ (2006 , 1002) ∷ (1002 , 2005) ∷ (2005 , 1000) ∷ []) (3 ∷ 2 ∷ 1 ∷ 3 ∷ []))) +_ : extend (link true 1 127 true (4006 ∷ []) ([]) false true true 3) (2000 , 2003) (valid (route tt true 127 8 false ((2003 , 4032) ∷ (4032 , 4012) ∷ (4012 , 4031) ∷ (4031 , 2004) ∷ (2004 , 2018) ∷ (2018 , 2039) ∷ (2039 , 4022) ∷ (4022 , 2007) ∷ (2007 , 4035) ∷ (4035 , 4030) ∷ (4030 , 4024) ∷ (4024 , 4023) ∷ (4023 , 4014) ∷ (4014 , 2021) ∷ (2021 , 4026) ∷ (4026 , 4037) ∷ (4037 , 4027) ∷ (4027 , 2020) ∷ (2020 , 2015) ∷ (2015 , 4019) ∷ (4019 , 4034) ∷ (4034 , 4036) ∷ (4036 , 2040) ∷ (2040 , 4025) ∷ (4025 , 4016) ∷ (4016 , 4001) ∷ (4001 , 2010) ∷ (2010 , 2028) ∷ (2028 , 4009) ∷ (4009 , 4033) ∷ (4033 , 2029) ∷ []) (3 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 127 false ([]) ([]) true false false 3) (1000 , 1005) (valid (route false 128 5 true ((1005 , 2006) ∷ (2006 , 1003) ∷ (1003 , 2001) ∷ []) (3 ∷ 3 ∷ 1 ∷ []))) - ≡ valid (route false 128 6 true ((1000 , 1005) ∷ (1005 , 2006) ∷ (2006 , 1003) ∷ (1003 , 2001) ∷ []) (3 ∷ 3 ∷ 3 ∷ 1 ∷ [])) +_ : extend (link true 4 0 true (4005 ∷ []) ([]) true false true 3) (2000 , 2005) (valid (route tt false 128 2 true ((2005 , 2001) ∷ (2001 , 2004) ∷ (2004 , 4006) ∷ (4006 , 2003) ∷ []) (1 ∷ 1 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route tt true 128 6 true ((2000 , 2005) ∷ (2005 , 2001) ∷ (2001 , 2004) ∷ (2004 , 4006) ∷ (4006 , 2003) ∷ []) (3 ∷ 1 ∷ 1 ∷ 2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 128 false (1002 ∷ []) (floor 1 2 1 3 ∷ []) false true true 2) (1000 , 2006) (valid (route false 0 9 false ((2006 , 1006) ∷ (1006 , 2005) ∷ (2005 , 2003) ∷ (2003 , 2004) ∷ []) (3 ∷ 1 ∷ 1 ∷ 2 ∷ []))) - ≡ valid (route false 128 10 false ((1000 , 2006) ∷ (2006 , 1006) ∷ (1006 , 2005) ∷ (2005 , 2003) ∷ (2003 , 2004) ∷ []) (2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 3 0 false ([]) ([]) false true false 2) (2000 , 2003) (valid (route tt false 0 0 true ((2003 , 3003) ∷ []) (0 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 1 255 false (2006 ∷ []) (floor 0 5 2 3 ∷ floor 3 1 2 1 ∷ floor 6 5 2 2 ∷ []) false false true 1) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 255 1 false ((1000 , 2006) ∷ []) (1 ∷ [])) +_ : extend (link true 2 127 false (2001 ∷ 4002 ∷ []) (floor 4 2 1 2 ∷ []) false true true 2) (2000 , 2002) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 127 2 false ((2000 , 2002) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 2 128 true ([]) ([]) false false false 1) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) - ≡ invalid +_ : extend (link true 4 127 false (4006 ∷ []) (floor 1 4 2 2 ∷ []) false true true 3) (2000 , 2002) (valid (route tt false 127 10 false ((2002 , 2004) ∷ (2004 , 2003) ∷ (2003 , 4001) ∷ (4001 , 2006) ∷ []) (1 ∷ 1 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route tt false 127 14 false ((2000 , 2002) ∷ (2002 , 2004) ∷ (2004 , 2003) ∷ (2003 , 4001) ∷ (4001 , 2006) ∷ []) (3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 127 false (1005 ∷ []) ([]) false false true 1) (1000 , 1002) (valid (route false 122 3 false ((1002 , 2002) ∷ (2002 , 2001) ∷ []) (1 ∷ 3 ∷ []))) - ≡ valid (route false 127 6 false ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 2001) ∷ []) (1 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 1 127 false ([]) (floor 4 6 2 3 ∷ []) true false true 2) (2000 , 4001) (valid (route tt false 128 7 false ((4001 , 2002) ∷ (2002 , 3002) ∷ []) (2 ∷ 0 ∷ []))) + ≡ valid (route tt false 128 8 true ((2000 , 4001) ∷ (4001 , 2002) ∷ (2002 , 3002) ∷ []) (2 ∷ 2 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 4 122 false (1001 ∷ 1004 ∷ []) ([]) true false true 2) (1000 , 1002) (valid (route true 122 1 false ((1002 , 1006) ∷ (1006 , 2002) ∷ []) (3 ∷ 1 ∷ []))) - ≡ valid (route true 122 5 true ((1000 , 1002) ∷ (1002 , 1006) ∷ (1006 , 2002) ∷ []) (2 ∷ 3 ∷ 1 ∷ [])) +_ : extend (link true 2 128 false (4006 ∷ []) (floor 3 1 2 3 ∷ []) false false true 2) (2000 , 4002) (valid (route tt false 255 2 true ((4002 , 4003) ∷ (4003 , 4004) ∷ (4004 , 2001) ∷ []) (3 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route tt false 255 4 true ((2000 , 4002) ∷ (4002 , 4003) ∷ (4003 , 4004) ∷ (4004 , 2001) ∷ []) (2 ∷ 3 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 122 false (1002 ∷ 2006 ∷ []) (floor 6 0 1 2 ∷ []) false true true 1) (1000 , 2001) (valid (route false 0 4 false ((2001 , 2004) ∷ (2004 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2002) ∷ []) (2 ∷ 1 ∷ 3 ∷ 1 ∷ []))) - ≡ valid (route true 122 5 false ((1000 , 2001) ∷ (2001 , 2004) ∷ (2004 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2002) ∷ []) (1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ [])) +_ : extend (link true 2 128 true (2005 ∷ []) (floor 1 1 2 3 ∷ floor 3 1 1 3 ∷ floor 6 4 1 3 ∷ []) false false true 3) (2000 , 4006) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 128 2 false ((2000 , 4006) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 2 0 false (1002 ∷ 2004 ∷ []) (floor 5 6 2 3 ∷ floor 6 5 2 3 ∷ []) false false true 2) (1000 , 2004) (valid (route true 127 3 false ((2004 , 2002) ∷ (2002 , 1005) ∷ (1005 , 1006) ∷ []) (2 ∷ 3 ∷ 1 ∷ []))) - ≡ invalid +_ : extend (link true 3 128 true ([]) (floor 2 0 1 1 ∷ floor 4 4 1 3 ∷ []) false true true 3) (2000 , 2005) (valid (route tt true 127 7 false ((2005 , 4001) ∷ []) (3 ∷ []))) + ≡ valid (route tt true 128 10 false ((2000 , 2005) ∷ (2005 , 4001) ∷ []) (3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 122 false (2001 ∷ []) (floor 3 3 2 0 ∷ floor 5 1 2 1 ∷ floor 5 4 2 3 ∷ []) false false false 1) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) +_ : extend (link true 4 255 false ([]) (floor 1 5 2 3 ∷ []) false false true 2) (2000 , 4003) (valid (route tt true 122 11 false ((4003 , 2006) ∷ (2006 , 2005) ∷ (2005 , 2000) ∷ (2000 , 2002) ∷ []) (2 ∷ 1 ∷ 2 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 127 false (1003 ∷ 2002 ∷ []) (floor 3 6 1 3 ∷ floor 5 1 2 3 ∷ floor 6 4 1 3 ∷ []) false false true 2) (1000 , 1005) (valid (route false 127 10 false ((1005 , 1000) ∷ (1000 , 2004) ∷ []) (1 ∷ 3 ∷ []))) - ≡ invalid +_ : extend (link true 2 127 true ([]) (floor 1 6 1 0 ∷ floor 4 3 2 0 ∷ []) false false false 2) (2000 , 2004) (valid (route tt false 122 9 false ((2004 , 2001) ∷ (2001 , 4002) ∷ (4002 , 4006) ∷ []) (3 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route tt true 127 11 false ((2000 , 2004) ∷ (2004 , 2001) ∷ (2001 , 4002) ∷ (4002 , 4006) ∷ []) (2 ∷ 3 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 0 false (1005 ∷ []) (floor 0 0 2 1 ∷ floor 1 3 1 3 ∷ floor 4 1 1 2 ∷ []) false false false 1) (1000 , 1001) (valid (route false 0 0 false ([]) ([]))) +_ : extend (link true 3 0 false (2005 ∷ []) (floor 4 4 1 1 ∷ []) false true false 3) (2000 , 4003) (valid (route tt true 127 6 true ((4003 , 4000) ∷ (4000 , 2006) ∷ (2006 , 2004) ∷ []) (2 ∷ 1 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 255 true (1001 ∷ []) (floor 1 3 1 2 ∷ floor 6 5 1 1 ∷ []) true false true 3) (1000 , 1005) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 255 4 true ((1000 , 1005) ∷ []) (3 ∷ [])) +_ : extend (link true 3 0 false (2002 ∷ []) (floor 4 2 2 2 ∷ floor 4 5 2 2 ∷ []) false false true 1) (2000 , 2002) (valid (route tt true 127 11 true ((2002 , 4006) ∷ []) (1 ∷ []))) + ≡ valid (route tt true 127 14 true ((2000 , 2002) ∷ (2002 , 4006) ∷ []) (1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 128 false (1005 ∷ 1006 ∷ []) (floor 1 1 2 1 ∷ floor 3 5 2 3 ∷ []) true false true 1) (1000 , 2003) (valid (route false 122 7 false ((2003 , 1003) ∷ (1003 , 1001) ∷ []) (2 ∷ 2 ∷ []))) - ≡ valid (route false 128 9 true ((1000 , 2003) ∷ (2003 , 1003) ∷ (1003 , 1001) ∷ []) (1 ∷ 2 ∷ 2 ∷ [])) +_ : extend (link true 2 255 false (2002 ∷ []) (floor 1 4 2 0 ∷ []) true false true 2) (2000 , 2003) (valid (route tt true 128 1 false ((2003 , 2001) ∷ []) (3 ∷ []))) + ≡ valid (route tt true 255 3 true ((2000 , 2003) ∷ (2003 , 2001) ∷ []) (2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 2 255 false ([]) (floor 1 2 2 1 ∷ floor 6 1 2 2 ∷ []) false false true 1) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 255 2 false ((1000 , 2006) ∷ []) (1 ∷ [])) +_ : extend (link true 3 122 false ([]) (floor 4 1 1 1 ∷ floor 5 4 1 3 ∷ floor 6 0 2 0 ∷ []) true false true 1) (2000 , 4002) (valid (route tt false 122 9 false ((4002 , 2006) ∷ (2006 , 2004) ∷ (2004 , 4001) ∷ []) (1 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route tt false 122 12 true ((2000 , 4002) ∷ (4002 , 2006) ∷ (2006 , 2004) ∷ (2004 , 4001) ∷ []) (1 ∷ 1 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 2 128 false ([]) (floor 3 5 2 0 ∷ floor 5 4 2 2 ∷ []) false true true 3) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 128 2 false ((1000 , 1003) ∷ []) (3 ∷ [])) +_ : extend (link true 3 122 false ([]) (floor 1 4 2 2 ∷ floor 6 2 1 1 ∷ []) false false false 3) (2000 , 2003) (valid (route tt false 0 0 true ((2003 , 3003) ∷ []) (0 ∷ []))) + ≡ valid (route tt false 122 3 true ((2000 , 2003) ∷ (2003 , 3003) ∷ []) (3 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 3 128 false (1004 ∷ 1006 ∷ []) (floor 0 3 1 3 ∷ []) false true true 1) (1000 , 2004) (valid (route false 0 1 false ((2004 , 2005) ∷ (2005 , 1001) ∷ []) (1 ∷ 2 ∷ []))) - ≡ valid (route false 128 4 false ((1000 , 2004) ∷ (2004 , 2005) ∷ (2005 , 1001) ∷ []) (1 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 3 122 false (4002 ∷ []) (floor 5 4 1 1 ∷ []) false false true 1) (2000 , 2001) (valid (route tt true 255 2 false ((2001 , 4004) ∷ []) (3 ∷ []))) + ≡ valid (route tt true 255 5 false ((2000 , 2001) ∷ (2001 , 4004) ∷ []) (1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 127 false ([]) (floor 1 0 2 1 ∷ []) false false false 2) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) - ≡ invalid +_ : extend (link true 4 127 false (4001 ∷ 2006 ∷ []) (floor 1 1 2 3 ∷ floor 4 5 1 0 ∷ []) false false true 1) (2000 , 2002) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 127 4 false ((2000 , 2002) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 1 0 true (2004 ∷ []) ([]) false false false 2) (1000 , 1002) (valid (route false 122 1 false ((1002 , 2002) ∷ (2002 , 1006) ∷ (1006 , 2001) ∷ []) (2 ∷ 1 ∷ 2 ∷ []))) - ≡ valid (route true 122 2 false ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 1006) ∷ (1006 , 2001) ∷ []) (2 ∷ 2 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 4 122 false (4006 ∷ []) ([]) false true true 3) (2000 , 2006) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 122 4 false ((2000 , 2006) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 2 128 false (2001 ∷ 2003 ∷ []) (floor 3 5 2 1 ∷ floor 4 2 2 0 ∷ floor 6 6 1 1 ∷ []) false false true 3) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 128 2 false ((1000 , 2006) ∷ []) (3 ∷ [])) +_ : extend (link true 3 255 true ([]) (floor 3 0 2 2 ∷ floor 3 6 1 0 ∷ floor 4 2 1 1 ∷ []) false false false 1) (2000 , 2006) (valid (route tt false 127 7 false ((2006 , 2003) ∷ (2003 , 2001) ∷ (2001 , 2005) ∷ []) (3 ∷ 3 ∷ 2 ∷ []))) + ≡ valid (route tt true 255 10 false ((2000 , 2006) ∷ (2006 , 2003) ∷ (2003 , 2001) ∷ (2001 , 2005) ∷ []) (1 ∷ 3 ∷ 3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 128 false (2001 ∷ []) (floor 3 3 1 2 ∷ []) true false true 1) (1000 , 2006) (valid (route false 122 0 false ((2006 , 2003) ∷ (2003 , 2004) ∷ []) (2 ∷ 3 ∷ []))) - ≡ valid (route false 128 3 true ((1000 , 2006) ∷ (2006 , 2003) ∷ (2003 , 2004) ∷ []) (1 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 3 122 true ([]) (floor 4 4 2 3 ∷ floor 5 3 1 3 ∷ []) true false false 2) (2000 , 2005) (valid (route tt true 127 5 true ((2005 , 4001) ∷ []) (3 ∷ []))) + ≡ valid (route tt true 127 8 true ((2000 , 2005) ∷ (2005 , 4001) ∷ []) (2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 128 false (1003 ∷ 2005 ∷ []) (floor 2 2 2 2 ∷ floor 4 0 1 3 ∷ []) true false true 3) (1000 , 1003) (valid (route false 127 0 false ((1003 , 2001) ∷ (2001 , 2003) ∷ (2003 , 2002) ∷ []) (3 ∷ 2 ∷ 3 ∷ []))) - ≡ valid (route true 128 4 true ((1000 , 1003) ∷ (1003 , 2001) ∷ (2001 , 2003) ∷ (2003 , 2002) ∷ []) (3 ∷ 3 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 4 122 false ([]) ([]) false true true 3) (2000 , 2004) (valid (route tt false 0 0 true ((2004 , 3004) ∷ []) (0 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 1 255 false (1003 ∷ 1005 ∷ []) (floor 5 4 1 1 ∷ []) false false true 1) (1000 , 2006) (valid (route false 127 8 false ((2006 , 1006) ∷ (1006 , 2003) ∷ (2003 , 2001) ∷ []) (3 ∷ 1 ∷ 2 ∷ []))) - ≡ valid (route false 255 9 false ((1000 , 2006) ∷ (2006 , 1006) ∷ (1006 , 2003) ∷ (2003 , 2001) ∷ []) (1 ∷ 3 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 4 255 false (2006 ∷ []) (floor 5 4 2 1 ∷ floor 6 3 2 0 ∷ []) false false true 1) (2000 , 2001) (valid (route tt true 255 9 false ((2001 , 2002) ∷ (2002 , 2003) ∷ (2003 , 2006) ∷ (2006 , 4004) ∷ []) (2 ∷ 2 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route tt true 255 13 false ((2000 , 2001) ∷ (2001 , 2002) ∷ (2002 , 2003) ∷ (2003 , 2006) ∷ (2006 , 4004) ∷ []) (1 ∷ 2 ∷ 2 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 2 0 false (1004 ∷ []) (floor 2 1 2 3 ∷ []) false false true 1) (1000 , 1006) (valid (route false 122 2 true ((1006 , 2002) ∷ []) (2 ∷ []))) - ≡ valid (route false 122 4 true ((1000 , 1006) ∷ (1006 , 2002) ∷ []) (1 ∷ 2 ∷ [])) +_ : extend (link true 1 0 false (4001 ∷ 2004 ∷ []) (floor 2 6 1 1 ∷ floor 4 0 1 3 ∷ floor 4 1 2 0 ∷ []) false true true 1) (2000 , 4006) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 1 false ((2000 , 4006) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 1 127 false (2005 ∷ []) (floor 5 6 1 1 ∷ []) true false true 3) (1000 , 1005) (valid (route true 0 10 false ((1005 , 2003) ∷ []) (2 ∷ []))) - ≡ valid (route true 127 11 true ((1000 , 1005) ∷ (1005 , 2003) ∷ []) (3 ∷ 2 ∷ [])) +_ : extend (link true 3 255 true (4002 ∷ []) (floor 3 0 2 1 ∷ []) false false true 3) (2000 , 2003) (valid (route tt false 127 0 false ((2003 , 4000) ∷ (4000 , 4005) ∷ []) (3 ∷ 1 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 2 128 true (2003 ∷ []) (floor 1 5 2 0 ∷ floor 2 0 1 0 ∷ floor 6 4 1 0 ∷ []) false false true 3) (1000 , 1004) (valid (route false 128 6 false ((1004 , 2004) ∷ (2004 , 1001) ∷ (1001 , 1005) ∷ (1005 , 2006) ∷ []) (2 ∷ 2 ∷ 2 ∷ 3 ∷ []))) - ≡ invalid +_ : extend (link true 2 128 false (2001 ∷ 4002 ∷ []) (floor 4 6 2 3 ∷ floor 6 1 2 1 ∷ []) false false true 1) (2000 , 4004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 128 2 false ((2000 , 4004) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 1 127 false (2005 ∷ 2006 ∷ []) (floor 3 2 1 0 ∷ []) false false false 3) (1000 , 1004) (valid (route false 0 10 true ((1004 , 1006) ∷ []) (3 ∷ []))) - ≡ valid (route false 127 11 true ((1000 , 1004) ∷ (1004 , 1006) ∷ []) (3 ∷ 3 ∷ [])) +_ : extend (link true 4 122 false (4001 ∷ 4002 ∷ []) ([]) false true true 1) (2000 , 2002) (valid (route tt false 122 1 false ((2002 , 2004) ∷ []) (1 ∷ []))) + ≡ valid (route tt false 122 5 false ((2000 , 2002) ∷ (2002 , 2004) ∷ []) (1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 0 true (2001 ∷ 2003 ∷ []) ([]) false false true 3) (1000 , 2005) (valid (route true 127 3 false ((2005 , 1006) ∷ (1006 , 2001) ∷ (2001 , 1000) ∷ (1000 , 1004) ∷ []) (3 ∷ 3 ∷ 1 ∷ 3 ∷ []))) - ≡ invalid +_ : extend (link true 1 127 false ([]) ([]) false false true 2) (2000 , 2002) (valid (route tt false 127 3 false ((2002 , 4001) ∷ (4001 , 2004) ∷ []) (3 ∷ 1 ∷ []))) + ≡ valid (route tt false 127 4 false ((2000 , 2002) ∷ (2002 , 4001) ∷ (4001 , 2004) ∷ []) (2 ∷ 3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 0 false (2002 ∷ 2006 ∷ []) (floor 6 2 2 2 ∷ []) false false true 3) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 0 2 false ((1000 , 2003) ∷ []) (3 ∷ [])) +_ : extend (link true 2 127 false (2003 ∷ 2004 ∷ []) (floor 1 0 1 0 ∷ floor 4 5 1 3 ∷ floor 6 1 1 1 ∷ []) false false true 2) (2000 , 4004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 127 2 false ((2000 , 4004) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 2 122 false (1006 ∷ []) (floor 1 1 2 2 ∷ floor 4 5 1 0 ∷ floor 5 6 1 1 ∷ []) false true true 1) (1000 , 2004) (valid (route false 122 7 false ((2004 , 1006) ∷ (1006 , 2003) ∷ (2003 , 1000) ∷ (1000 , 2002) ∷ []) (1 ∷ 2 ∷ 3 ∷ 3 ∷ []))) - ≡ invalid +_ : extend (link true 3 127 true ([]) ([]) false false true 2) (2000 , 2003) (valid (route tt false 127 9 true ((2003 , 2001) ∷ []) (3 ∷ []))) + ≡ valid (route tt true 127 12 true ((2000 , 2003) ∷ (2003 , 2001) ∷ []) (2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 2 127 false ([]) (floor 6 4 1 1 ∷ []) true false true 2) (1000 , 2002) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 127 2 true ((1000 , 2002) ∷ []) (2 ∷ [])) +_ : extend (link true 2 255 false (4005 ∷ 2006 ∷ []) (floor 1 1 1 2 ∷ floor 2 1 2 3 ∷ []) true false true 2) (2000 , 4004) (valid (route tt true 127 11 true ((4004 , 2001) ∷ (2001 , 4005) ∷ (4005 , 2003) ∷ (2003 , 2002) ∷ []) (2 ∷ 2 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route tt true 255 13 true ((2000 , 4004) ∷ (4004 , 2001) ∷ (2001 , 4005) ∷ (4005 , 2003) ∷ (2003 , 2002) ∷ []) (2 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 0 false ([]) (floor 0 4 1 1 ∷ floor 2 6 2 2 ∷ []) false false false 3) (1000 , 2003) (valid (route false 127 0 false ((2003 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2006) ∷ []) (1 ∷ 3 ∷ 2 ∷ 2 ∷ []))) - ≡ valid (route false 127 3 false ((1000 , 2003) ∷ (2003 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2006) ∷ []) (3 ∷ 1 ∷ 3 ∷ 2 ∷ 2 ∷ [])) +_ : extend (link true 3 122 true ([]) (floor 3 3 2 0 ∷ floor 3 4 2 2 ∷ floor 4 1 1 2 ∷ []) false true true 2) (2000 , 2006) (valid (route tt false 0 8 false ((2006 , 2005) ∷ (2005 , 2004) ∷ []) (1 ∷ 3 ∷ []))) + ≡ valid (route tt true 122 11 false ((2000 , 2006) ∷ (2006 , 2005) ∷ (2005 , 2004) ∷ []) (2 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 127 false ([]) ([]) false false true 2) (1000 , 2001) (valid (route false 127 8 true ((2001 , 2005) ∷ (2005 , 2003) ∷ []) (3 ∷ 3 ∷ []))) - ≡ valid (route false 127 9 true ((1000 , 2001) ∷ (2001 , 2005) ∷ (2005 , 2003) ∷ []) (2 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 4 0 false ([]) (floor 3 0 1 1 ∷ floor 4 1 2 2 ∷ []) false false true 3) (2000 , 4005) (valid (route tt false 0 9 false ((4005 , 4004) ∷ (4004 , 4003) ∷ (4003 , 4006) ∷ []) (2 ∷ 3 ∷ 1 ∷ []))) + ≡ valid (route tt false 0 13 false ((2000 , 4005) ∷ (4005 , 4004) ∷ (4004 , 4003) ∷ (4003 , 4006) ∷ []) (3 ∷ 2 ∷ 3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 255 true (2001 ∷ 2003 ∷ []) ([]) false false true 2) (1000 , 2002) (valid (route false 128 3 false ((2002 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (3 ∷ 2 ∷ 3 ∷ []))) - ≡ valid (route true 255 5 false ((1000 , 2002) ∷ (2002 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (2 ∷ 3 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 1 128 false ([]) (floor 5 2 1 1 ∷ floor 5 4 2 2 ∷ []) false false true 2) (2000 , 2005) (valid (route tt true 0 2 false ((2005 , 4003) ∷ (4003 , 2004) ∷ (2004 , 2001) ∷ []) (1 ∷ 2 ∷ 1 ∷ []))) + ≡ valid (route tt true 128 3 false ((2000 , 2005) ∷ (2005 , 4003) ∷ (4003 , 2004) ∷ (2004 , 2001) ∷ []) (2 ∷ 1 ∷ 2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 0 false (1005 ∷ []) ([]) false false true 1) (1000 , 2005) (valid (route false 122 7 true ((2005 , 2004) ∷ (2004 , 1005) ∷ []) (1 ∷ 1 ∷ []))) - ≡ valid (route true 122 8 true ((1000 , 2005) ∷ (2005 , 2004) ∷ (2004 , 1005) ∷ []) (1 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 2 0 false (4005 ∷ 2006 ∷ []) (floor 1 1 2 2 ∷ floor 4 0 2 3 ∷ floor 5 4 2 1 ∷ []) false true true 3) (2000 , 2006) (valid (route tt false 0 0 true ((2006 , 3006) ∷ []) (0 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 2 0 false (1001 ∷ 1004 ∷ []) (floor 2 5 2 0 ∷ floor 4 5 1 3 ∷ []) false false true 1) (1000 , 2005) (valid (route false 128 9 false ((2005 , 2006) ∷ []) (1 ∷ []))) - ≡ valid (route false 128 11 false ((1000 , 2005) ∷ (2005 , 2006) ∷ []) (1 ∷ 1 ∷ [])) +_ : extend (link true 2 255 true ([]) (floor 6 2 2 3 ∷ []) true false true 3) (2000 , 4001) (valid (route tt true 255 6 false ((4001 , 2005) ∷ []) (1 ∷ []))) + ≡ valid (route tt true 255 8 true ((2000 , 4001) ∷ (4001 , 2005) ∷ []) (3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 0 false ([]) (floor 1 2 2 0 ∷ floor 4 3 2 3 ∷ floor 6 3 1 1 ∷ []) false false false 3) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) - ≡ invalid +_ : extend (link true 3 0 false ([]) (floor 3 3 2 2 ∷ []) false false true 3) (2000 , 2003) (valid (route tt true 128 7 true ((2003 , 2005) ∷ []) (3 ∷ []))) + ≡ valid (route tt true 128 10 true ((2000 , 2003) ∷ (2003 , 2005) ∷ []) (3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 122 true (1005 ∷ 2005 ∷ []) (floor 1 4 1 1 ∷ floor 6 1 2 0 ∷ []) false false false 3) (1000 , 1003) (valid (route false 128 3 false ((1003 , 2005) ∷ (2005 , 2003) ∷ (2003 , 1000) ∷ (1000 , 2006) ∷ []) (3 ∷ 2 ∷ 1 ∷ 2 ∷ []))) +_ : extend (link true 3 127 false (2004 ∷ []) (floor 6 0 2 1 ∷ []) false true true 1) (2000 , 4004) (valid (route tt false 255 1 true ((4004 , 2003) ∷ (2003 , 4001) ∷ (4001 , 2005) ∷ []) (3 ∷ 3 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 0 false (1002 ∷ 1005 ∷ []) ([]) false true true 1) (1000 , 1006) (valid (route false 0 4 false ((1006 , 1001) ∷ (1001 , 1005) ∷ (1005 , 1003) ∷ []) (2 ∷ 2 ∷ 3 ∷ []))) - ≡ valid (route true 0 5 false ((1000 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1005) ∷ (1005 , 1003) ∷ []) (1 ∷ 2 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 1 127 false ([]) (floor 3 5 1 0 ∷ floor 5 1 1 1 ∷ floor 6 1 1 2 ∷ []) false true false 1) (2000 , 4002) (valid (route tt true 127 4 false ((4002 , 2001) ∷ []) (1 ∷ []))) + ≡ valid (route tt true 127 5 false ((2000 , 4002) ∷ (4002 , 2001) ∷ []) (1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 0 true (1002 ∷ []) ([]) false false true 2) (1000 , 2005) (valid (route false 127 11 false ((2005 , 1004) ∷ []) (1 ∷ []))) - ≡ valid (route true 127 13 false ((1000 , 2005) ∷ (2005 , 1004) ∷ []) (2 ∷ 1 ∷ [])) +_ : extend (link true 4 128 false (2003 ∷ 4003 ∷ []) (floor 1 0 2 3 ∷ floor 3 0 1 2 ∷ floor 5 0 1 1 ∷ []) true false true 1) (2000 , 4003) (valid (route tt false 122 7 true ((4003 , 4006) ∷ []) (1 ∷ []))) + ≡ valid (route tt true 128 11 true ((2000 , 4003) ∷ (4003 , 4006) ∷ []) (1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 128 false (2002 ∷ []) (floor 1 5 1 2 ∷ floor 3 0 1 2 ∷ floor 5 4 2 3 ∷ []) false false false 1) (1000 , 1001) (valid (route false 255 6 false ((1001 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1004) ∷ []) (2 ∷ 1 ∷ 1 ∷ []))) - ≡ invalid +_ : extend (link true 3 0 false (4005 ∷ []) (floor 3 0 1 0 ∷ floor 5 3 1 1 ∷ []) true false true 2) (2000 , 4003) (valid (route tt false 0 0 true ((4003 , 5003) ∷ []) (0 ∷ []))) + ≡ valid (route tt false 0 3 true ((2000 , 4003) ∷ (4003 , 5003) ∷ []) (2 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 3 127 false (2004 ∷ []) ([]) false false true 2) (1000 , 1006) (valid (route false 128 3 true ((1006 , 1002) ∷ []) (1 ∷ []))) - ≡ valid (route false 128 6 true ((1000 , 1006) ∷ (1006 , 1002) ∷ []) (2 ∷ 1 ∷ [])) +_ : extend (link true 4 128 false ([]) (floor 5 0 1 2 ∷ []) false false true 1) (2000 , 4002) (valid (route tt true 255 0 true ((4002 , 2003) ∷ (2003 , 4001) ∷ (4001 , 2006) ∷ (2006 , 2004) ∷ []) (1 ∷ 3 ∷ 3 ∷ 1 ∷ []))) + ≡ valid (route tt true 255 4 true ((2000 , 4002) ∷ (4002 , 2003) ∷ (2003 , 4001) ∷ (4001 , 2006) ∷ (2006 , 2004) ∷ []) (1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 0 false (1001 ∷ 1003 ∷ []) (floor 4 0 2 1 ∷ floor 4 5 2 0 ∷ floor 6 6 2 1 ∷ []) true true true 3) (1000 , 2001) (valid (route false 122 5 true ((2001 , 2002) ∷ []) (2 ∷ []))) - ≡ invalid +_ : extend (link true 4 0 false ([]) (floor 1 3 2 0 ∷ floor 1 4 2 2 ∷ floor 2 5 2 2 ∷ []) false true true 3) (2000 , 4002) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 4 false ((2000 , 4002) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 1 127 false (1005 ∷ []) (floor 3 3 1 3 ∷ []) true true false 3) (1000 , 1001) (valid (route true 122 0 false ((1001 , 1036) ∷ (1036 , 2016) ∷ (2016 , 2025) ∷ (2025 , 2032) ∷ (2032 , 2017) ∷ (2017 , 1027) ∷ (1027 , 2039) ∷ (2039 , 2035) ∷ (2035 , 2020) ∷ (2020 , 1023) ∷ (1023 , 1024) ∷ (1024 , 2007) ∷ (2007 , 2009) ∷ (2009 , 1011) ∷ (1011 , 1010) ∷ (1010 , 2004) ∷ (2004 , 2030) ∷ (2030 , 1008) ∷ (1008 , 1019) ∷ (1019 , 1003) ∷ (1003 , 1038) ∷ (1038 , 2012) ∷ (2012 , 1021) ∷ (1021 , 1034) ∷ (1034 , 2015) ∷ (2015 , 2022) ∷ (2022 , 1018) ∷ (1018 , 2014) ∷ (2014 , 1028) ∷ (1028 , 1031) ∷ (1031 , 1013) ∷ (1013 , 2029) ∷ []) (3 ∷ 2 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ []))) +_ : extend (link true 1 255 false (2001 ∷ []) (floor 1 4 1 0 ∷ floor 4 6 2 2 ∷ floor 6 3 1 0 ∷ []) true true true 3) (2000 , 2005) (valid (route tt true 128 5 false ((2005 , 2002) ∷ (2002 , 2000) ∷ (2000 , 4006) ∷ []) (1 ∷ 1 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 128 false ([]) (floor 6 3 1 2 ∷ []) false false true 1) (1000 , 2005) (valid (route false 255 8 false ((2005 , 1001) ∷ (1001 , 2006) ∷ []) (2 ∷ 3 ∷ []))) - ≡ valid (route false 255 12 false ((1000 , 2005) ∷ (2005 , 1001) ∷ (1001 , 2006) ∷ []) (1 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 4 255 true (2006 ∷ []) (floor 6 0 1 1 ∷ floor 6 2 2 1 ∷ []) false false true 1) (2000 , 2003) (valid (route tt false 255 11 true ((2003 , 2001) ∷ (2001 , 3001) ∷ []) (2 ∷ 0 ∷ []))) + ≡ valid (route tt true 255 15 true ((2000 , 2003) ∷ (2003 , 2001) ∷ (2001 , 3001) ∷ []) (1 ∷ 2 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 1 128 false (1002 ∷ []) (floor 1 5 1 3 ∷ floor 4 3 1 2 ∷ []) false true false 2) (1000 , 2006) (valid (route true 255 8 false ((2006 , 1003) ∷ []) (2 ∷ []))) - ≡ valid (route true 255 9 false ((1000 , 2006) ∷ (2006 , 1003) ∷ []) (2 ∷ 2 ∷ [])) +_ : extend (link true 4 122 true (2001 ∷ 4004 ∷ []) (floor 4 4 1 2 ∷ []) false false true 1) (2000 , 2002) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 122 4 false ((2000 , 2002) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 4 128 false (1006 ∷ []) (floor 3 5 1 0 ∷ []) true true true 2) (1000 , 2006) (valid (route true 0 7 false ((2006 , 1005) ∷ (1005 , 2003) ∷ (2003 , 2001) ∷ []) (1 ∷ 2 ∷ 1 ∷ []))) - ≡ valid (route true 128 11 true ((1000 , 2006) ∷ (2006 , 1005) ∷ (1005 , 2003) ∷ (2003 , 2001) ∷ []) (2 ∷ 1 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 2 127 false (4003 ∷ []) ([]) false false true 3) (2000 , 4003) (valid (route tt true 122 3 true ((4003 , 2005) ∷ (2005 , 4004) ∷ (4004 , 2001) ∷ (2001 , 2006) ∷ []) (2 ∷ 3 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route tt true 127 5 true ((2000 , 4003) ∷ (4003 , 2005) ∷ (2005 , 4004) ∷ (4004 , 2001) ∷ (2001 , 2006) ∷ []) (3 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 0 true ([]) (floor 0 5 1 0 ∷ floor 4 4 1 0 ∷ floor 6 0 2 1 ∷ []) false true true 2) (1000 , 2004) (valid (route false 255 4 false ((2004 , 1004) ∷ []) (3 ∷ []))) - ≡ valid (route true 255 7 false ((1000 , 2004) ∷ (2004 , 1004) ∷ []) (2 ∷ 3 ∷ [])) +_ : extend (link true 2 0 false ([]) (floor 3 0 1 1 ∷ floor 5 1 2 0 ∷ floor 6 6 2 1 ∷ []) false true true 1) (2000 , 2003) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 2 false ((2000 , 2003) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 1 255 false ([]) (floor 2 4 2 0 ∷ []) false false true 2) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 255 1 false ((1000 , 2003) ∷ []) (2 ∷ [])) +_ : extend (link true 2 0 false ([]) (floor 1 3 2 2 ∷ floor 4 0 2 2 ∷ floor 5 4 1 1 ∷ []) true true true 1) (2000 , 2006) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 2 true ((2000 , 2006) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 3 128 false ([]) (floor 0 6 2 3 ∷ []) false true true 3) (1000 , 2001) (valid (route false 122 0 true ((2001 , 2003) ∷ (2003 , 1002) ∷ (1002 , 1000) ∷ []) (1 ∷ 1 ∷ 1 ∷ []))) +_ : extend (link true 4 127 false ([]) (floor 3 0 1 2 ∷ floor 4 0 2 3 ∷ floor 4 2 1 1 ∷ []) true false false 3) (2000 , 2001) (valid (route tt false 127 10 true ((2001 , 4002) ∷ (4002 , 2003) ∷ (2003 , 4004) ∷ (4004 , 4000) ∷ []) (1 ∷ 2 ∷ 3 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 122 false ([]) (floor 2 0 2 3 ∷ []) true false true 2) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 122 3 true ((1000 , 2006) ∷ []) (2 ∷ [])) +_ : extend (link true 3 128 false ([]) (floor 1 5 1 1 ∷ floor 3 3 2 2 ∷ floor 3 5 2 3 ∷ []) false false false 1) (2000 , 4002) (valid (route tt false 122 3 false ((4002 , 2003) ∷ []) (1 ∷ []))) + ≡ valid (route tt false 128 6 false ((2000 , 4002) ∷ (4002 , 2003) ∷ []) (1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 122 false (1002 ∷ 2005 ∷ []) (floor 1 5 2 3 ∷ floor 3 4 1 0 ∷ floor 5 4 2 2 ∷ []) true false true 1) (1000 , 2003) (valid (route false 127 9 true ((2003 , 1000) ∷ []) (2 ∷ []))) - ≡ invalid +_ : extend (link true 3 128 false ([]) ([]) false false true 3) (2000 , 2005) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 128 3 false ((2000 , 2005) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 1 127 false (1004 ∷ 2006 ∷ []) (floor 5 3 1 3 ∷ []) false true true 3) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 127 1 false ((1000 , 2004) ∷ []) (3 ∷ [])) +_ : extend (link true 2 255 false ([]) (floor 1 2 1 0 ∷ []) false false true 3) (2000 , 4004) (valid (route tt false 0 8 true ((4004 , 2001) ∷ (2001 , 2003) ∷ (2003 , 4005) ∷ []) (1 ∷ 2 ∷ 1 ∷ []))) + ≡ valid (route tt false 255 10 true ((2000 , 4004) ∷ (4004 , 2001) ∷ (2001 , 2003) ∷ (2003 , 4005) ∷ []) (3 ∷ 1 ∷ 2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 0 false (2005 ∷ []) (floor 0 3 2 1 ∷ floor 5 3 1 0 ∷ floor 6 3 1 1 ∷ []) true false false 1) (1000 , 2006) (valid (route false 128 5 false ((2006 , 1005) ∷ (1005 , 1004) ∷ (1004 , 1000) ∷ []) (3 ∷ 3 ∷ 1 ∷ []))) +_ : extend (link true 1 127 false ([]) (floor 1 4 2 0 ∷ floor 3 6 2 1 ∷ floor 6 1 1 0 ∷ []) true false true 2) (2000 , 4006) (valid (route tt true 255 10 false ((4006 , 2033) ∷ (2033 , 2001) ∷ (2001 , 4031) ∷ (4031 , 4024) ∷ (4024 , 4002) ∷ (4002 , 2022) ∷ (2022 , 2014) ∷ (2014 , 2003) ∷ (2003 , 4038) ∷ (4038 , 2007) ∷ (2007 , 4039) ∷ (4039 , 4029) ∷ (4029 , 4019) ∷ (4019 , 2008) ∷ (2008 , 4004) ∷ (4004 , 4037) ∷ (4037 , 2026) ∷ (2026 , 4005) ∷ (4005 , 2021) ∷ (2021 , 2040) ∷ (2040 , 4013) ∷ (4013 , 4025) ∷ (4025 , 4015) ∷ (4015 , 4011) ∷ (4011 , 2028) ∷ (2028 , 4017) ∷ (4017 , 2034) ∷ (2034 , 4035) ∷ (4035 , 2009) ∷ (2009 , 4027) ∷ (4027 , 2012) ∷ (2012 , 2023) ∷ []) (3 ∷ 3 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 127 false ([]) (floor 3 5 2 3 ∷ floor 5 2 2 1 ∷ floor 6 3 2 2 ∷ []) false false false 2) (1000 , 2002) (valid (route false 127 10 false ((2002 , 1005) ∷ (1005 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1000) ∷ []) (2 ∷ 3 ∷ 1 ∷ 1 ∷ []))) +_ : extend (link true 1 127 false (4004 ∷ []) (floor 1 1 1 1 ∷ floor 2 5 2 1 ∷ floor 5 3 2 2 ∷ []) false true true 1) (2000 , 2003) (valid (route tt false 128 8 true ((2003 , 2004) ∷ []) (3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 122 false (1004 ∷ 1006 ∷ []) ([]) true false false 2) (1000 , 1001) (valid (route false 127 0 false ((1001 , 1004) ∷ (1004 , 2001) ∷ (2001 , 2005) ∷ []) (3 ∷ 2 ∷ 1 ∷ []))) - ≡ valid (route true 127 1 true ((1000 , 1001) ∷ (1001 , 1004) ∷ (1004 , 2001) ∷ (2001 , 2005) ∷ []) (2 ∷ 3 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 4 127 false (2003 ∷ 2004 ∷ []) (floor 5 4 1 2 ∷ floor 5 6 2 1 ∷ floor 6 1 1 3 ∷ []) false false true 3) (2000 , 2005) (valid (route tt true 128 2 false ((2005 , 2002) ∷ (2002 , 2000) ∷ []) (3 ∷ 1 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 1 127 true (2001 ∷ []) (floor 1 4 2 0 ∷ floor 4 1 2 0 ∷ []) false false false 3) (1000 , 1004) (valid (route false 122 0 false ((1004 , 2003) ∷ (2003 , 2002) ∷ []) (1 ∷ 1 ∷ []))) - ≡ valid (route true 127 1 false ((1000 , 1004) ∷ (1004 , 2003) ∷ (2003 , 2002) ∷ []) (3 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 2 128 false ([]) (floor 3 3 1 3 ∷ floor 3 6 2 3 ∷ floor 5 2 1 2 ∷ []) false false true 2) (2000 , 4001) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 128 2 false ((2000 , 4001) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 4 0 false ([]) (floor 2 0 1 0 ∷ floor 5 5 2 3 ∷ floor 6 6 1 2 ∷ []) false false true 2) (1000 , 1005) (valid (route false 255 1 true ((1005 , 2004) ∷ (2004 , 1003) ∷ []) (1 ∷ 3 ∷ []))) - ≡ valid (route false 255 5 true ((1000 , 1005) ∷ (1005 , 2004) ∷ (2004 , 1003) ∷ []) (2 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 2 122 false (2001 ∷ 2006 ∷ []) (floor 2 1 1 0 ∷ floor 5 0 2 0 ∷ floor 5 6 2 0 ∷ []) false false true 2) (2000 , 2005) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 122 2 false ((2000 , 2005) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 3 122 true ([]) (floor 1 3 2 0 ∷ []) true false true 1) (1000 , 2005) (valid (route true 122 5 false ((2005 , 1005) ∷ (1005 , 2001) ∷ []) (2 ∷ 1 ∷ []))) - ≡ valid (route true 122 8 true ((1000 , 2005) ∷ (2005 , 1005) ∷ (1005 , 2001) ∷ []) (1 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 1 128 false (2003 ∷ []) (floor 1 2 1 2 ∷ floor 5 2 2 3 ∷ floor 5 5 2 2 ∷ []) true false true 3) (2000 , 2005) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 128 1 true ((2000 , 2005) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 2 255 true (2004 ∷ []) (floor 1 3 2 0 ∷ floor 3 6 1 1 ∷ []) false true false 1) (1000 , 1001) (valid (route false 0 0 false ([]) ([]))) - ≡ invalid +_ : extend (link true 3 255 false (4004 ∷ []) ([]) false false true 3) (2000 , 4002) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 255 3 false ((2000 , 4002) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 2 255 false ([]) ([]) false false true 1) (1000 , 1004) (valid (route false 127 3 false ((1004 , 2003) ∷ []) (2 ∷ []))) - ≡ valid (route false 255 5 false ((1000 , 1004) ∷ (1004 , 2003) ∷ []) (1 ∷ 2 ∷ [])) +_ : extend (link true 3 127 false (2006 ∷ []) (floor 2 3 1 1 ∷ floor 5 2 1 0 ∷ floor 6 5 1 2 ∷ []) false true false 1) (2000 , 4004) (valid (route tt true 0 2 true ((4004 , 4001) ∷ (4001 , 2002) ∷ (2002 , 3002) ∷ []) (3 ∷ 1 ∷ 0 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 1 127 false ([]) (floor 1 0 2 2 ∷ floor 6 6 2 1 ∷ []) false false true 3) (1000 , 1003) (valid (route false 122 2 false ((1003 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1004) ∷ []) (3 ∷ 2 ∷ 3 ∷ []))) - ≡ valid (route false 127 3 false ((1000 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1004) ∷ []) (3 ∷ 3 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 4 128 false (2003 ∷ []) (floor 1 1 2 2 ∷ floor 1 3 2 0 ∷ floor 6 6 2 3 ∷ []) false true true 2) (2000 , 2005) (valid (route tt true 128 10 false ((2005 , 2001) ∷ (2001 , 2006) ∷ (2006 , 4003) ∷ []) (1 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route tt true 128 14 false ((2000 , 2005) ∷ (2005 , 2001) ∷ (2001 , 2006) ∷ (2006 , 4003) ∷ []) (2 ∷ 1 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 127 false ([]) (floor 0 1 1 3 ∷ floor 4 5 2 1 ∷ []) false true true 1) (1000 , 1004) (valid (route false 255 8 false ((1004 , 1000) ∷ (1000 , 1001) ∷ (1001 , 2002) ∷ []) (1 ∷ 2 ∷ 2 ∷ []))) +_ : extend (link true 4 255 true (4003 ∷ []) (floor 2 3 2 0 ∷ floor 4 2 2 2 ∷ floor 5 1 2 2 ∷ []) false true true 2) (2000 , 2004) (valid (route tt true 127 9 true ((2004 , 4005) ∷ (4005 , 2006) ∷ (2006 , 3006) ∷ []) (1 ∷ 1 ∷ 0 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 127 false (1003 ∷ 2002 ∷ []) (floor 0 5 1 1 ∷ floor 5 1 2 1 ∷ []) false false true 2) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 127 4 false ((1000 , 1003) ∷ []) (2 ∷ [])) +_ : extend (link true 4 0 false ([]) (floor 5 1 2 1 ∷ floor 5 2 1 0 ∷ floor 5 5 1 2 ∷ []) false false true 1) (2000 , 2004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 4 false ((2000 , 2004) ∷ []) (1 ∷ [])) +_ = refl + +_ : extend (link true 2 0 false (2002 ∷ []) (floor 2 2 2 0 ∷ floor 6 0 1 1 ∷ []) false false true 1) (2000 , 2004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 2 false ((2000 , 2004) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 0 false ([]) (floor 0 4 1 1 ∷ floor 6 0 1 0 ∷ []) false false true 3) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 0 2 false ((1000 , 2005) ∷ []) (3 ∷ [])) +_ : extend (link true 3 122 false (4005 ∷ []) ([]) true false true 3) (2000 , 2006) (valid (route tt false 0 0 true ((2006 , 3006) ∷ []) (0 ∷ []))) + ≡ valid (route tt false 122 3 true ((2000 , 2006) ∷ (2006 , 3006) ∷ []) (3 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 4 255 false (2004 ∷ []) (floor 1 2 1 3 ∷ []) false false true 1) (1000 , 2002) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 255 4 false ((1000 , 2002) ∷ []) (1 ∷ [])) +_ : extend (link true 1 255 false ([]) ([]) true true true 1) (2000 , 4002) (valid (route tt false 0 8 false ((4002 , 2005) ∷ (2005 , 2004) ∷ (2004 , 2001) ∷ (2001 , 3001) ∷ []) (2 ∷ 3 ∷ 1 ∷ 0 ∷ []))) + ≡ valid (route tt false 255 9 true ((2000 , 4002) ∷ (4002 , 2005) ∷ (2005 , 2004) ∷ (2004 , 2001) ∷ (2001 , 3001) ∷ []) (1 ∷ 2 ∷ 3 ∷ 1 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 2 0 true (2005 ∷ []) (floor 2 4 1 3 ∷ floor 3 2 2 2 ∷ []) false true true 3) (1000 , 2002) (valid (route false 0 3 false ((2002 , 1005) ∷ []) (1 ∷ []))) - ≡ valid (route true 0 5 false ((1000 , 2002) ∷ (2002 , 1005) ∷ []) (3 ∷ 1 ∷ [])) +_ : extend (link true 4 127 false ([]) (floor 1 0 1 1 ∷ []) true false true 2) (2000 , 2005) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 127 4 true ((2000 , 2005) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 4 128 false (1004 ∷ 1005 ∷ []) (floor 1 1 1 0 ∷ floor 3 3 1 2 ∷ floor 6 1 2 2 ∷ []) false false false 3) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) +_ : extend (link true 1 127 false (2001 ∷ []) (floor 2 5 2 1 ∷ floor 5 6 2 2 ∷ []) false false true 3) (2000 , 4005) (valid (route tt false 255 1 false ((4005 , 2000) ∷ (2000 , 2004) ∷ (2004 , 4006) ∷ (4006 , 2003) ∷ []) (1 ∷ 3 ∷ 1 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 255 false (1005 ∷ 1006 ∷ []) ([]) false false false 1) (1000 , 1003) (valid (route false 122 10 true ((1003 , 2028) ∷ (2028 , 2002) ∷ (2002 , 2036) ∷ (2036 , 1026) ∷ (1026 , 2003) ∷ (2003 , 2020) ∷ (2020 , 2021) ∷ (2021 , 1034) ∷ (1034 , 2012) ∷ (2012 , 1011) ∷ (1011 , 2006) ∷ (2006 , 1025) ∷ (1025 , 1017) ∷ (1017 , 1032) ∷ (1032 , 1008) ∷ (1008 , 1005) ∷ (1005 , 2016) ∷ (2016 , 2038) ∷ (2038 , 2013) ∷ (2013 , 2015) ∷ (2015 , 1022) ∷ (1022 , 1035) ∷ (1035 , 2030) ∷ (2030 , 1019) ∷ (1019 , 2001) ∷ (2001 , 1039) ∷ (1039 , 2029) ∷ (2029 , 2023) ∷ (2023 , 2010) ∷ (2010 , 2031) ∷ (2031 , 1009) ∷ []) (1 ∷ 1 ∷ 2 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ []))) +_ : extend (link true 1 255 true (2004 ∷ []) (floor 1 4 1 3 ∷ floor 3 6 2 2 ∷ floor 4 5 2 2 ∷ []) false false true 2) (2000 , 2005) (valid (route tt false 0 0 true ((2005 , 3005) ∷ []) (0 ∷ []))) + ≡ valid (route tt true 255 1 true ((2000 , 2005) ∷ (2005 , 3005) ∷ []) (2 ∷ 0 ∷ [])) +_ = refl + +_ : extend (link true 2 122 true ([]) ([]) false false true 3) (2000 , 4006) (valid (route tt true 255 8 true ((4006 , 4002) ∷ (4002 , 2004) ∷ []) (2 ∷ 2 ∷ []))) + ≡ valid (route tt true 255 10 true ((2000 , 4006) ∷ (4006 , 4002) ∷ (4002 , 2004) ∷ []) (3 ∷ 2 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 4 255 false (4005 ∷ []) (floor 4 1 2 1 ∷ floor 6 4 2 2 ∷ []) true false true 3) (2000 , 2001) (valid (route tt true 128 1 false ((2001 , 4002) ∷ (4002 , 4006) ∷ []) (2 ∷ 2 ∷ []))) + ≡ valid (route tt true 255 5 true ((2000 , 2001) ∷ (2001 , 4002) ∷ (4002 , 4006) ∷ []) (3 ∷ 2 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 128 false (2002 ∷ []) ([]) false true false 1) (2000 , 4003) (valid (route tt false 127 7 false ((4003 , 2001) ∷ (2001 , 2002) ∷ (2002 , 4006) ∷ (4006 , 5006) ∷ []) (3 ∷ 1 ∷ 1 ∷ 0 ∷ []))) + ≡ valid (route tt true 128 10 false ((2000 , 4003) ∷ (4003 , 2001) ∷ (2001 , 2002) ∷ (2002 , 4006) ∷ (4006 , 5006) ∷ []) (1 ∷ 3 ∷ 1 ∷ 1 ∷ 0 ∷ [])) +_ = refl + +_ : extend (link true 1 255 true ([]) ([]) false true true 2) (2000 , 2002) (valid (route tt true 0 5 true ((2002 , 2004) ∷ (2004 , 4005) ∷ (4005 , 4006) ∷ (4006 , 4001) ∷ []) (3 ∷ 1 ∷ 1 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 0 false (2002 ∷ []) (floor 5 2 2 2 ∷ []) false true false 1) (1000 , 1002) (valid (route false 128 11 true ((1002 , 1005) ∷ (1005 , 1001) ∷ []) (1 ∷ 3 ∷ []))) +_ : extend (link true 1 122 false (4005 ∷ []) (floor 4 4 1 1 ∷ []) false false false 3) (2000 , 2006) (valid (route tt false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 3 127 true ([]) (floor 0 2 2 3 ∷ floor 4 3 1 1 ∷ floor 6 1 2 0 ∷ []) true false true 2) (1000 , 1003) (valid (route false 128 9 false ((1003 , 1002) ∷ (1002 , 2001) ∷ (2001 , 1004) ∷ []) (2 ∷ 3 ∷ 3 ∷ []))) - ≡ valid (route true 128 12 true ((1000 , 1003) ∷ (1003 , 1002) ∷ (1002 , 2001) ∷ (2001 , 1004) ∷ []) (2 ∷ 2 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 1 122 true (4001 ∷ 4002 ∷ []) ([]) false false false 3) (2000 , 2001) (valid (route tt false 0 6 true ((2001 , 4004) ∷ []) (2 ∷ []))) + ≡ valid (route tt true 122 7 true ((2000 , 2001) ∷ (2001 , 4004) ∷ []) (3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 4 128 false (2001 ∷ []) ([]) false false true 3) (1000 , 2006) (valid (route false 255 2 false ((2006 , 1006) ∷ (1006 , 1002) ∷ (1002 , 2001) ∷ []) (1 ∷ 2 ∷ 2 ∷ []))) - ≡ valid (route true 255 6 false ((1000 , 2006) ∷ (2006 , 1006) ∷ (1006 , 1002) ∷ (1002 , 2001) ∷ []) (3 ∷ 1 ∷ 2 ∷ 2 ∷ [])) +_ : extend (link true 4 127 true (4006 ∷ []) ([]) false false true 1) (2000 , 4006) (valid (route tt true 127 0 false ((4006 , 4004) ∷ []) (2 ∷ []))) + ≡ valid (route tt true 127 4 false ((2000 , 4006) ∷ (4006 , 4004) ∷ []) (1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 2 127 false ([]) (floor 1 1 1 1 ∷ floor 6 6 2 2 ∷ []) false false true 3) (1000 , 2004) (valid (route false 255 2 false ((2004 , 2002) ∷ (2002 , 2006) ∷ (2006 , 1003) ∷ []) (2 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route false 255 4 false ((1000 , 2004) ∷ (2004 , 2002) ∷ (2002 , 2006) ∷ (2006 , 1003) ∷ []) (3 ∷ 2 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 4 127 false (2001 ∷ 4001 ∷ []) (floor 2 3 1 1 ∷ floor 5 3 2 3 ∷ floor 6 1 2 2 ∷ []) true false true 3) (2000 , 2005) (valid (route tt false 0 0 true ((2005 , 3005) ∷ []) (0 ∷ []))) + ≡ valid (route tt false 127 4 true ((2000 , 2005) ∷ (2005 , 3005) ∷ []) (3 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 1 0 false (1003 ∷ []) ([]) true false false 2) (1000 , 2004) (valid (route false 127 6 true ((2004 , 2005) ∷ (2005 , 1004) ∷ (1004 , 2002) ∷ []) (1 ∷ 1 ∷ 2 ∷ []))) - ≡ valid (route false 127 7 true ((1000 , 2004) ∷ (2004 , 2005) ∷ (2005 , 1004) ∷ (1004 , 2002) ∷ []) (2 ∷ 1 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 1 128 true ([]) (floor 4 1 1 3 ∷ floor 4 3 1 1 ∷ []) true true true 2) (2000 , 4006) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 128 1 true ((2000 , 4006) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 3 255 true (1002 ∷ 2006 ∷ []) (floor 4 3 2 1 ∷ []) true true true 1) (1000 , 2001) (valid (route false 0 2 true ((2001 , 1000) ∷ (1000 , 2005) ∷ (2005 , 2004) ∷ []) (3 ∷ 1 ∷ 1 ∷ []))) - ≡ invalid +_ : extend (link true 1 0 false ([]) (floor 5 0 1 3 ∷ floor 5 3 2 3 ∷ []) false true true 3) (2000 , 4006) (valid (route tt false 255 7 false ((4006 , 4002) ∷ (4002 , 4001) ∷ []) (3 ∷ 2 ∷ []))) + ≡ valid (route tt false 255 8 false ((2000 , 4006) ∷ (4006 , 4002) ∷ (4002 , 4001) ∷ []) (3 ∷ 3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 127 true ([]) ([]) false false true 2) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 127 3 false ((1000 , 2005) ∷ []) (2 ∷ [])) +_ : extend (link true 4 122 false (4005 ∷ []) (floor 1 4 1 2 ∷ floor 6 3 2 3 ∷ []) false false true 2) (2000 , 4006) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 122 4 false ((2000 , 4006) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 4 128 false (1003 ∷ 2004 ∷ []) (floor 1 1 2 0 ∷ floor 2 5 1 0 ∷ []) true true true 2) (1000 , 1003) (valid (route false 122 9 true ((1003 , 2002) ∷ (2002 , 2006) ∷ (2006 , 2003) ∷ (2003 , 1001) ∷ []) (2 ∷ 1 ∷ 3 ∷ 1 ∷ []))) +_ : extend (link true 4 122 false ([]) (floor 5 5 1 2 ∷ floor 6 6 2 0 ∷ []) false false false 1) (2000 , 2005) (valid (route tt false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 2 128 true ([]) ([]) false false false 3) (1000 , 2001) (valid (route false 128 6 true ((2001 , 2004) ∷ []) (3 ∷ []))) - ≡ valid (route true 128 8 true ((1000 , 2001) ∷ (2001 , 2004) ∷ []) (3 ∷ 3 ∷ [])) +_ : extend (link true 1 127 false ([]) (floor 1 1 2 3 ∷ []) true false true 1) (2000 , 4002) (valid (route tt false 255 2 false ((4002 , 4004) ∷ (4004 , 2005) ∷ (2005 , 2001) ∷ []) (2 ∷ 3 ∷ 1 ∷ []))) + ≡ valid (route tt false 255 3 true ((2000 , 4002) ∷ (4002 , 4004) ∷ (4004 , 2005) ∷ (2005 , 2001) ∷ []) (1 ∷ 2 ∷ 3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 128 false ([]) (floor 0 3 1 2 ∷ floor 2 1 2 2 ∷ []) false true true 3) (1000 , 1001) (valid (route false 127 10 true ((1001 , 1003) ∷ (1003 , 1004) ∷ (1004 , 1006) ∷ (1006 , 1000) ∷ []) (2 ∷ 1 ∷ 3 ∷ 1 ∷ []))) +_ : extend (link true 4 255 false ([]) (floor 6 2 1 3 ∷ floor 6 6 1 1 ∷ []) false false false 2) (2000 , 2002) (valid (route tt false 122 1 false ((2002 , 2000) ∷ (2000 , 2004) ∷ (2004 , 4001) ∷ (4001 , 5001) ∷ []) (3 ∷ 3 ∷ 2 ∷ 0 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 122 false (1004 ∷ 1006 ∷ []) (floor 6 3 2 0 ∷ []) false false true 2) (1000 , 1002) (valid (route false 128 10 true ((1002 , 1005) ∷ (1005 , 1006) ∷ (1006 , 1000) ∷ []) (3 ∷ 2 ∷ 3 ∷ []))) +_ : extend (link true 1 127 true ([]) (floor 3 3 2 2 ∷ floor 3 6 1 3 ∷ floor 4 6 2 0 ∷ []) false false true 1) (2000 , 4001) (valid (route tt false 255 2 false ((4001 , 4002) ∷ (4002 , 2005) ∷ []) (2 ∷ 2 ∷ []))) + ≡ valid (route tt true 255 3 false ((2000 , 4001) ∷ (4001 , 4002) ∷ (4002 , 2005) ∷ []) (1 ∷ 2 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 1 128 false (4003 ∷ 2005 ∷ []) (floor 1 3 1 3 ∷ floor 5 0 2 3 ∷ floor 5 5 1 3 ∷ []) true false true 1) (2000 , 2001) (valid (route tt false 122 0 false ((2001 , 2003) ∷ (2003 , 4004) ∷ (4004 , 5004) ∷ []) (1 ∷ 3 ∷ 0 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 255 true (2002 ∷ 2003 ∷ []) ([]) true false true 1) (1000 , 1002) (valid (route true 128 10 true ((1002 , 2006) ∷ (2006 , 2005) ∷ []) (1 ∷ 3 ∷ []))) - ≡ valid (route true 255 13 true ((1000 , 1002) ∷ (1002 , 2006) ∷ (2006 , 2005) ∷ []) (1 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 2 122 false ([]) (floor 2 2 1 3 ∷ []) false true true 3) (2000 , 4005) (valid (route tt false 0 4 false ((4005 , 2001) ∷ []) (1 ∷ []))) + ≡ valid (route tt false 122 6 false ((2000 , 4005) ∷ (4005 , 2001) ∷ []) (3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 3 255 false ([]) (floor 5 1 2 3 ∷ floor 5 3 2 1 ∷ []) false false true 1) (1000 , 2002) (valid (route true 255 11 true ((2002 , 2004) ∷ (2004 , 1000) ∷ (1000 , 1001) ∷ []) (2 ∷ 2 ∷ 3 ∷ []))) - ≡ invalid +_ : extend (link true 1 127 false (2001 ∷ 4003 ∷ []) (floor 2 0 2 1 ∷ floor 2 3 2 1 ∷ floor 2 5 2 1 ∷ []) false false true 2) (2000 , 4006) (valid (route tt true 122 1 false ((4006 , 4005) ∷ (4005 , 2004) ∷ []) (1 ∷ 3 ∷ []))) + ≡ valid (route tt true 127 2 false ((2000 , 4006) ∷ (4006 , 4005) ∷ (4005 , 2004) ∷ []) (2 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 2 255 false (1002 ∷ []) ([]) false false true 3) (1000 , 1004) (valid (route false 255 8 false ((1004 , 1000) ∷ (1000 , 1002) ∷ (1002 , 2006) ∷ []) (1 ∷ 2 ∷ 1 ∷ []))) +_ : extend (link true 1 0 false ([]) (floor 5 0 2 2 ∷ []) false false false 2) (2000 , 2002) (valid (route tt false 255 10 false ((2002 , 2011) ∷ (2011 , 2022) ∷ (2022 , 2009) ∷ (2009 , 4019) ∷ (4019 , 2040) ∷ (2040 , 4004) ∷ (4004 , 2010) ∷ (2010 , 4029) ∷ (4029 , 4027) ∷ (4027 , 4001) ∷ (4001 , 2012) ∷ (2012 , 2036) ∷ (2036 , 4021) ∷ (4021 , 2024) ∷ (2024 , 2013) ∷ (2013 , 2038) ∷ (2038 , 2014) ∷ (2014 , 4039) ∷ (4039 , 4028) ∷ (4028 , 4031) ∷ (4031 , 4016) ∷ (4016 , 2037) ∷ (2037 , 4005) ∷ (4005 , 4026) ∷ (4026 , 4034) ∷ (4034 , 2023) ∷ (2023 , 2018) ∷ (2018 , 2033) ∷ (2033 , 2032) ∷ (2032 , 4030) ∷ (4030 , 2035) ∷ (2035 , 4007) ∷ []) (1 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 2 ∷ 2 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 127 false (2006 ∷ []) ([]) true false false 2) (1000 , 1003) (valid (route false 255 11 true ((1003 , 2005) ∷ []) (3 ∷ []))) - ≡ valid (route false 255 14 true ((1000 , 1003) ∷ (1003 , 2005) ∷ []) (2 ∷ 3 ∷ [])) +_ : extend (link true 3 0 false (2004 ∷ []) (floor 1 3 2 3 ∷ floor 3 1 2 0 ∷ []) true true true 3) (2000 , 2002) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 3 true ((2000 , 2002) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 1 127 false (2005 ∷ []) (floor 1 2 1 2 ∷ floor 3 6 2 1 ∷ []) false true false 2) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) - ≡ invalid +_ : extend (link true 3 128 false ([]) (floor 4 1 2 2 ∷ []) true false true 2) (2000 , 2003) (valid (route tt false 255 5 false ((2003 , 4001) ∷ []) (3 ∷ []))) + ≡ valid (route tt false 255 8 true ((2000 , 2003) ∷ (2003 , 4001) ∷ []) (2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 128 false (1006 ∷ []) (floor 0 5 2 0 ∷ floor 5 5 2 2 ∷ []) false true true 1) (1000 , 2003) (valid (route false 128 5 true ((2003 , 1002) ∷ []) (3 ∷ []))) +_ : extend (link true 1 128 true (2003 ∷ []) (floor 3 0 2 1 ∷ floor 4 0 1 1 ∷ floor 6 3 2 2 ∷ []) false false false 3) (2000 , 4003) (valid (route tt false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 4 128 false (1005 ∷ 2005 ∷ []) (floor 2 1 2 2 ∷ floor 3 5 1 0 ∷ floor 5 0 1 3 ∷ []) true false true 2) (1000 , 1001) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 128 4 true ((1000 , 1001) ∷ []) (2 ∷ [])) +_ : extend (link true 4 0 true ([]) (floor 5 0 1 2 ∷ []) true true false 3) (2000 , 4001) (valid (route tt false 122 0 false ((4001 , 4002) ∷ []) (1 ∷ []))) + ≡ valid (route tt true 122 4 true ((2000 , 4001) ∷ (4001 , 4002) ∷ []) (3 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 1 0 false (2001 ∷ []) (floor 1 1 2 2 ∷ floor 2 2 1 3 ∷ floor 6 0 1 3 ∷ []) true false true 3) (2000 , 2001) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 0 1 true ((2000 , 2001) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 2 0 false (2005 ∷ 2006 ∷ []) ([]) false false true 2) (1000 , 1001) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 0 2 false ((1000 , 1001) ∷ []) (2 ∷ [])) +_ : extend (link true 1 128 false ([]) (floor 4 3 2 3 ∷ floor 5 5 2 0 ∷ []) true false true 1) (2000 , 2006) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 128 1 true ((2000 , 2006) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 3 128 true (2004 ∷ []) (floor 1 3 2 3 ∷ floor 4 0 1 3 ∷ floor 5 4 2 1 ∷ []) true false true 1) (1000 , 1002) (valid (route false 122 8 true ((1002 , 2002) ∷ (2002 , 2006) ∷ []) (2 ∷ 3 ∷ []))) - ≡ valid (route true 128 11 true ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 2006) ∷ []) (1 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 3 127 false (4004 ∷ []) (floor 2 4 1 0 ∷ floor 3 6 2 0 ∷ floor 5 2 2 1 ∷ []) false true false 1) (2000 , 4006) (valid (route tt false 255 6 false ((4006 , 2004) ∷ (2004 , 4002) ∷ []) (1 ∷ 1 ∷ []))) + ≡ valid (route tt false 255 9 false ((2000 , 4006) ∷ (4006 , 2004) ∷ (2004 , 4002) ∷ []) (1 ∷ 1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 128 true (1005 ∷ 2002 ∷ []) (floor 1 2 1 3 ∷ floor 5 0 1 1 ∷ []) true true true 2) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 128 2 true ((1000 , 2004) ∷ []) (2 ∷ [])) +_ : extend (link true 2 128 false (4001 ∷ 2006 ∷ []) ([]) false false false 2) (2000 , 4004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ invalid _ = refl -_ : extend (link true 4 0 false (1006 ∷ 2006 ∷ []) (floor 4 5 1 2 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 2 true ((1002 , 2005) ∷ (2005 , 1003) ∷ []) (3 ∷ 1 ∷ []))) - ≡ valid (route false 0 6 true ((1000 , 1002) ∷ (1002 , 2005) ∷ (2005 , 1003) ∷ []) (2 ∷ 3 ∷ 1 ∷ [])) +_ : extend (link true 4 255 false ([]) (floor 2 2 2 0 ∷ []) true false true 3) (2000 , 2003) (valid (route tt true 122 6 true ((2003 , 2005) ∷ (2005 , 2006) ∷ (2006 , 4000) ∷ []) (3 ∷ 2 ∷ 1 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 4 0 false ([]) (floor 2 1 2 1 ∷ floor 5 1 1 2 ∷ floor 6 3 2 2 ∷ []) true true false 3) (1000 , 1001) (valid (route false 255 10 false ((1001 , 1002) ∷ (1002 , 1000) ∷ (1000 , 2005) ∷ []) (2 ∷ 3 ∷ 2 ∷ []))) +_ : extend (link true 4 122 false (4004 ∷ 2005 ∷ []) (floor 5 2 2 0 ∷ floor 6 5 2 0 ∷ floor 6 6 1 1 ∷ []) false true true 1) (2000 , 4003) (valid (route tt false 0 6 false ((4003 , 4006) ∷ (4006 , 4004) ∷ (4004 , 4000) ∷ []) (2 ∷ 3 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 2 122 false (2001 ∷ []) (floor 6 4 2 3 ∷ []) false false true 2) (1000 , 2005) (valid (route false 122 7 false ((2005 , 1002) ∷ []) (2 ∷ []))) - ≡ valid (route false 122 9 false ((1000 , 2005) ∷ (2005 , 1002) ∷ []) (2 ∷ 2 ∷ [])) +_ : extend (link true 3 128 false ([]) (floor 5 5 2 0 ∷ floor 6 5 1 3 ∷ []) false false true 3) (2000 , 2006) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 128 3 false ((2000 , 2006) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 1 127 true (2005 ∷ []) (floor 1 4 2 3 ∷ floor 1 6 1 2 ∷ floor 2 4 2 2 ∷ []) false false false 2) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) +_ : extend (link true 2 127 false (4001 ∷ 2003 ∷ []) (floor 4 2 1 1 ∷ floor 6 5 1 3 ∷ []) false false true 2) (2000 , 2001) (valid (route tt false 122 6 false ((2001 , 2000) ∷ (2000 , 4002) ∷ (4002 , 4004) ∷ []) (2 ∷ 3 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 2 0 true ([]) ([]) false false false 1) (1000 , 2005) (valid (route false 122 8 false ((2005 , 1001) ∷ (1001 , 1005) ∷ (1005 , 1000) ∷ []) (2 ∷ 1 ∷ 1 ∷ []))) +_ : extend (link true 3 127 false ([]) (floor 1 3 2 2 ∷ floor 2 6 2 1 ∷ floor 3 4 1 3 ∷ []) true false true 3) (2000 , 4006) (valid (route tt false 127 8 false ((4006 , 2000) ∷ []) (2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 2 127 false (1003 ∷ 2003 ∷ []) (floor 1 1 2 2 ∷ []) false false true 2) (1000 , 1003) (valid (route true 127 11 false ((1003 , 2005) ∷ []) (3 ∷ []))) - ≡ valid (route true 127 13 false ((1000 , 1003) ∷ (1003 , 2005) ∷ []) (2 ∷ 3 ∷ [])) +_ : extend (link true 2 255 false (4002 ∷ 2005 ∷ []) ([]) false false false 1) (2000 , 4002) (valid (route tt false 122 0 true ((4002 , 4000) ∷ (4000 , 2005) ∷ (2005 , 4003) ∷ []) (3 ∷ 3 ∷ 1 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 3 128 false (1004 ∷ 2004 ∷ []) (floor 5 4 2 3 ∷ floor 6 5 2 2 ∷ []) true true true 1) (1000 , 1001) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 128 3 true ((1000 , 1001) ∷ []) (1 ∷ [])) +_ : extend (link true 3 128 true (2006 ∷ []) (floor 6 1 2 2 ∷ floor 6 2 2 1 ∷ []) false true true 2) (2000 , 2006) (valid (route tt true 122 1 false ((2006 , 2000) ∷ []) (1 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 1 255 false (1004 ∷ 2004 ∷ []) (floor 2 0 1 1 ∷ floor 2 5 2 2 ∷ floor 6 5 1 3 ∷ []) false true true 3) (1000 , 2003) (valid (route false 255 8 false ((2003 , 2002) ∷ []) (1 ∷ []))) - ≡ valid (route false 255 9 false ((1000 , 2003) ∷ (2003 , 2002) ∷ []) (3 ∷ 1 ∷ [])) +_ : extend (link true 4 255 false ([]) (floor 6 2 1 0 ∷ floor 6 5 2 3 ∷ []) true false true 2) (2000 , 4006) (valid (route tt true 0 0 false ((4006 , 4000) ∷ (4000 , 4002) ∷ (4002 , 2005) ∷ (2005 , 4003) ∷ []) (2 ∷ 1 ∷ 1 ∷ 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 2 255 true (4003 ∷ 2004 ∷ []) ([]) true false true 3) (2000 , 4003) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 255 2 true ((2000 , 4003) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 1 0 true (2002 ∷ []) (floor 2 4 1 1 ∷ floor 3 5 1 0 ∷ floor 6 1 1 0 ∷ []) true true true 3) (1000 , 1006) (valid (route true 255 7 false ((1006 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2001) ∷ (2001 , 1003) ∷ []) (3 ∷ 3 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route true 255 8 true ((1000 , 1006) ∷ (1006 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2001) ∷ (2001 , 1003) ∷ []) (3 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 1 255 false ([]) (floor 1 2 2 3 ∷ floor 3 0 1 0 ∷ floor 6 0 1 0 ∷ []) true false true 3) (2000 , 2002) (valid (route tt false 127 9 false ((2002 , 4003) ∷ (4003 , 4006) ∷ (4006 , 4004) ∷ (4004 , 5004) ∷ []) (2 ∷ 2 ∷ 1 ∷ 0 ∷ []))) + ≡ valid (route tt false 255 10 true ((2000 , 2002) ∷ (2002 , 4003) ∷ (4003 , 4006) ∷ (4006 , 4004) ∷ (4004 , 5004) ∷ []) (3 ∷ 2 ∷ 2 ∷ 1 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 1 128 false (2006 ∷ []) (floor 4 5 2 2 ∷ []) false false true 2) (1000 , 1003) (valid (route true 255 5 false ((1003 , 2005) ∷ []) (1 ∷ []))) - ≡ valid (route true 255 6 false ((1000 , 1003) ∷ (1003 , 2005) ∷ []) (2 ∷ 1 ∷ [])) +_ : extend (link true 3 0 false ([]) (floor 1 5 2 2 ∷ []) false false false 1) (2000 , 2002) (valid (route tt false 128 3 true ((2002 , 4005) ∷ (4005 , 2006) ∷ (2006 , 2004) ∷ (2004 , 2003) ∷ []) (1 ∷ 2 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route tt false 128 6 true ((2000 , 2002) ∷ (2002 , 4005) ∷ (4005 , 2006) ∷ (2006 , 2004) ∷ (2004 , 2003) ∷ []) (1 ∷ 1 ∷ 2 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 122 true ([]) (floor 2 5 2 3 ∷ []) false false false 1) (1000 , 2005) (valid (route false 127 7 true ((2005 , 1000) ∷ (1000 , 2004) ∷ []) (1 ∷ 1 ∷ []))) +_ : extend (link true 1 128 true ([]) (floor 1 5 2 2 ∷ floor 4 1 2 0 ∷ []) false false false 1) (2000 , 4003) (valid (route tt true 127 3 false ((4003 , 4000) ∷ (4000 , 4004) ∷ (4004 , 4006) ∷ []) (2 ∷ 3 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 122 false (1004 ∷ []) (floor 0 2 2 0 ∷ floor 0 5 1 0 ∷ floor 4 6 1 1 ∷ []) false false false 3) (1000 , 1001) (valid (route false 255 9 true ((1001 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (2 ∷ 2 ∷ 1 ∷ []))) - ≡ valid (route false 255 13 true ((1000 , 1001) ∷ (1001 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (3 ∷ 2 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 3 255 false (4002 ∷ 2004 ∷ []) ([]) true false true 3) (2000 , 2002) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 255 3 true ((2000 , 2002) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 2 255 true (2005 ∷ []) ([]) false false true 3) (1000 , 2002) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 255 2 false ((1000 , 2002) ∷ []) (3 ∷ [])) +_ : extend (link true 4 255 true (4001 ∷ 2003 ∷ []) (floor 2 5 1 2 ∷ floor 2 6 1 1 ∷ floor 4 0 2 3 ∷ []) true false true 1) (2000 , 4004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 255 4 true ((2000 , 4004) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 4 128 false (2006 ∷ []) (floor 5 2 1 3 ∷ []) false false true 1) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 128 4 false ((1000 , 2006) ∷ []) (1 ∷ [])) +_ : extend (link true 4 127 false ([]) (floor 5 3 1 3 ∷ floor 6 3 2 3 ∷ []) false false true 3) (2000 , 2006) (valid (route tt false 127 4 false ((2006 , 2004) ∷ (2004 , 3004) ∷ []) (2 ∷ 0 ∷ []))) + ≡ valid (route tt false 127 8 false ((2000 , 2006) ∷ (2006 , 2004) ∷ (2004 , 3004) ∷ []) (3 ∷ 2 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 2 255 false (2004 ∷ []) (floor 1 0 2 2 ∷ floor 3 5 2 1 ∷ []) false true true 1) (1000 , 1002) (valid (route false 127 7 false ((1002 , 2005) ∷ (2005 , 2001) ∷ (2001 , 2003) ∷ (2003 , 1000) ∷ []) (1 ∷ 3 ∷ 3 ∷ 2 ∷ []))) - ≡ invalid +_ : extend (link true 1 0 false (4004 ∷ []) (floor 3 1 2 3 ∷ []) false false true 1) (2000 , 4004) (valid (route tt false 0 0 true ((4004 , 5004) ∷ []) (0 ∷ []))) + ≡ valid (route tt true 0 1 true ((2000 , 4004) ∷ (4004 , 5004) ∷ []) (1 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 3 122 false ([]) (floor 0 6 1 1 ∷ floor 1 0 1 0 ∷ []) true false true 3) (1000 , 2002) (valid (route true 128 8 false ((2002 , 2003) ∷ []) (1 ∷ []))) - ≡ valid (route true 128 11 true ((1000 , 2002) ∷ (2002 , 2003) ∷ []) (3 ∷ 1 ∷ [])) +_ : extend (link true 3 127 true ([]) (floor 4 2 2 0 ∷ floor 5 1 2 2 ∷ floor 5 3 2 2 ∷ []) false false true 1) (2000 , 4001) (valid (route tt true 127 8 true ((4001 , 4006) ∷ (4006 , 2002) ∷ []) (1 ∷ 1 ∷ []))) + ≡ valid (route tt true 127 11 true ((2000 , 4001) ∷ (4001 , 4006) ∷ (4006 , 2002) ∷ []) (1 ∷ 1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 255 true (1001 ∷ 2004 ∷ []) (floor 1 3 2 3 ∷ []) false false true 1) (1000 , 2001) (valid (route false 128 7 false ((2001 , 1003) ∷ (1003 , 1000) ∷ (1000 , 2006) ∷ []) (1 ∷ 1 ∷ 3 ∷ []))) - ≡ invalid +_ : extend (link true 4 122 true (2003 ∷ 2004 ∷ []) (floor 1 3 1 1 ∷ floor 5 6 1 0 ∷ []) false false true 1) (2000 , 4004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 122 4 false ((2000 , 4004) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 3 128 false ([]) ([]) true false true 1) (1000 , 1005) (valid (route true 255 0 true ((1005 , 2002) ∷ (2002 , 1000) ∷ (1000 , 2005) ∷ (2005 , 1001) ∷ []) (3 ∷ 1 ∷ 2 ∷ 1 ∷ []))) - ≡ invalid +_ : extend (link true 3 255 true (2002 ∷ []) ([]) false false false 2) (2000 , 2002) (valid (route tt false 122 5 false ((2002 , 4005) ∷ (4005 , 4004) ∷ []) (1 ∷ 2 ∷ []))) + ≡ valid (route tt true 255 8 false ((2000 , 2002) ∷ (2002 , 4005) ∷ (4005 , 4004) ∷ []) (2 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 0 false (1006 ∷ []) (floor 5 1 2 1 ∷ []) true false false 3) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) +_ : extend (link true 4 0 false (2006 ∷ []) (floor 4 2 1 2 ∷ floor 4 5 1 3 ∷ []) false false true 2) (2000 , 4001) (valid (route tt false 128 1 false ((4001 , 2004) ∷ (2004 , 2005) ∷ (2005 , 4003) ∷ []) (2 ∷ 2 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 255 false ([]) (floor 2 5 1 2 ∷ []) true false true 2) (1000 , 1002) (valid (route false 0 1 false ((1002 , 1003) ∷ (1003 , 2002) ∷ (2002 , 1006) ∷ []) (2 ∷ 3 ∷ 3 ∷ []))) - ≡ valid (route false 255 5 true ((1000 , 1002) ∷ (1002 , 1003) ∷ (1003 , 2002) ∷ (2002 , 1006) ∷ []) (2 ∷ 2 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 3 128 true ([]) (floor 2 4 2 1 ∷ floor 4 3 2 0 ∷ floor 6 5 1 2 ∷ []) false false true 3) (2000 , 4005) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 128 3 false ((2000 , 4005) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 3 122 false (1004 ∷ 2002 ∷ []) ([]) false true true 2) (1000 , 1001) (valid (route false 255 8 true ((1001 , 2003) ∷ []) (3 ∷ []))) - ≡ invalid +_ : extend (link true 1 255 false ([]) (floor 1 1 1 3 ∷ floor 1 5 2 3 ∷ floor 5 3 1 2 ∷ []) false false true 3) (2000 , 2005) (valid (route tt false 255 10 false ((2005 , 2004) ∷ (2004 , 2003) ∷ []) (2 ∷ 1 ∷ []))) + ≡ valid (route tt false 255 11 false ((2000 , 2005) ∷ (2005 , 2004) ∷ (2004 , 2003) ∷ []) (3 ∷ 2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 255 false ([]) (floor 1 4 2 0 ∷ []) true true true 3) (1000 , 2002) (valid (route false 127 0 false ((2002 , 1000) ∷ []) (3 ∷ []))) +_ : extend (link true 1 127 false (4004 ∷ []) (floor 1 6 2 3 ∷ floor 3 1 2 2 ∷ floor 6 4 1 3 ∷ []) true false false 1) (2000 , 2005) (valid (route tt false 127 6 false ((2005 , 2016) ∷ (2016 , 4037) ∷ (4037 , 2030) ∷ (2030 , 4022) ∷ (4022 , 4040) ∷ (4040 , 2023) ∷ (2023 , 4024) ∷ (4024 , 4028) ∷ (4028 , 2035) ∷ (2035 , 4033) ∷ (4033 , 2038) ∷ (2038 , 2014) ∷ (2014 , 4008) ∷ (4008 , 2007) ∷ (2007 , 4032) ∷ (4032 , 4011) ∷ (4011 , 2015) ∷ (2015 , 2002) ∷ (2002 , 4004) ∷ (4004 , 4029) ∷ (4029 , 2021) ∷ (2021 , 4010) ∷ (4010 , 4027) ∷ (4027 , 4039) ∷ (4039 , 2013) ∷ (2013 , 2020) ∷ (2020 , 4003) ∷ (4003 , 4012) ∷ (4012 , 4019) ∷ (4019 , 4017) ∷ (4017 , 4036) ∷ (4036 , 4025) ∷ []) (3 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 0 false (2001 ∷ []) (floor 0 0 2 2 ∷ floor 2 2 2 0 ∷ floor 6 1 2 1 ∷ []) false true true 1) (1000 , 2003) (valid (route false 127 2 false ((2003 , 1004) ∷ (1004 , 1002) ∷ (1002 , 2001) ∷ []) (1 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route true 127 6 false ((1000 , 2003) ∷ (2003 , 1004) ∷ (1004 , 1002) ∷ (1002 , 2001) ∷ []) (1 ∷ 1 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 2 127 false (2003 ∷ []) (floor 4 6 2 0 ∷ floor 5 4 1 3 ∷ []) false false true 2) (2000 , 2002) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 127 2 false ((2000 , 2002) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 4 127 false (1006 ∷ 2004 ∷ []) ([]) true true true 2) (1000 , 1004) (valid (route false 128 0 false ((1004 , 2005) ∷ []) (1 ∷ []))) - ≡ valid (route false 128 4 true ((1000 , 1004) ∷ (1004 , 2005) ∷ []) (2 ∷ 1 ∷ [])) +_ : extend (link true 2 122 false (4001 ∷ []) (floor 4 6 2 0 ∷ floor 6 6 2 0 ∷ []) false true true 3) (2000 , 4001) (valid (route tt false 128 0 true ((4001 , 2002) ∷ []) (1 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 2 127 false (1002 ∷ 1005 ∷ []) (floor 2 2 2 3 ∷ floor 3 0 2 3 ∷ floor 6 2 1 2 ∷ []) false false true 3) (1000 , 1004) (valid (route true 127 9 false ((1004 , 2003) ∷ []) (3 ∷ []))) - ≡ valid (route true 127 11 false ((1000 , 1004) ∷ (1004 , 2003) ∷ []) (3 ∷ 3 ∷ [])) +_ : extend (link true 1 122 false (4002 ∷ []) (floor 2 6 2 3 ∷ []) false false false 3) (2000 , 2006) (valid (route tt false 0 9 false ((2006 , 2003) ∷ (2003 , 4005) ∷ (4005 , 5005) ∷ []) (1 ∷ 2 ∷ 0 ∷ []))) + ≡ valid (route tt false 122 10 false ((2000 , 2006) ∷ (2006 , 2003) ∷ (2003 , 4005) ∷ (4005 , 5005) ∷ []) (3 ∷ 1 ∷ 2 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 4 127 false (1003 ∷ []) (floor 4 0 2 3 ∷ floor 5 3 2 2 ∷ floor 5 5 1 2 ∷ []) true false true 3) (1000 , 2004) (valid (route false 255 10 false ((2004 , 1006) ∷ (1006 , 1000) ∷ (1000 , 1001) ∷ (1001 , 1004) ∷ []) (3 ∷ 1 ∷ 3 ∷ 1 ∷ []))) - ≡ invalid +_ : extend (link true 3 122 false (2006 ∷ []) ([]) true false true 2) (2000 , 4004) (valid (route tt false 255 0 true ((4004 , 2005) ∷ []) (1 ∷ []))) + ≡ valid (route tt false 255 3 true ((2000 , 4004) ∷ (4004 , 2005) ∷ []) (2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 0 false ([]) (floor 1 0 2 0 ∷ floor 2 5 1 2 ∷ []) false false true 1) (1000 , 2006) (valid (route false 122 9 true ((2006 , 2002) ∷ (2002 , 1003) ∷ []) (1 ∷ 1 ∷ []))) - ≡ valid (route false 122 10 true ((1000 , 2006) ∷ (2006 , 2002) ∷ (2002 , 1003) ∷ []) (1 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 2 0 false (2002 ∷ 4005 ∷ []) ([]) false true true 1) (2000 , 4004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 2 false ((2000 , 4004) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 255 false ([]) (floor 0 3 2 2 ∷ floor 4 2 2 0 ∷ floor 6 1 2 2 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 255 2 false ((1000 , 1002) ∷ []) (2 ∷ [])) +_ : extend (link true 2 122 false ([]) (floor 4 0 1 2 ∷ floor 4 4 1 1 ∷ floor 6 2 1 2 ∷ []) true false true 2) (2000 , 2003) (valid (route tt false 0 0 true ((2003 , 3003) ∷ []) (0 ∷ []))) + ≡ valid (route tt false 122 2 true ((2000 , 2003) ∷ (2003 , 3003) ∷ []) (2 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 1 127 false (1005 ∷ 2001 ∷ []) (floor 6 1 1 3 ∷ []) true false false 2) (1000 , 1004) (valid (route true 255 0 false ((1004 , 1002) ∷ (1002 , 1005) ∷ (1005 , 2003) ∷ []) (1 ∷ 2 ∷ 1 ∷ []))) - ≡ valid (route true 255 1 true ((1000 , 1004) ∷ (1004 , 1002) ∷ (1002 , 1005) ∷ (1005 , 2003) ∷ []) (2 ∷ 1 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 4 128 true ([]) ([]) false true true 2) (2000 , 4002) (valid (route tt false 255 9 true ((4002 , 2005) ∷ (2005 , 4004) ∷ []) (3 ∷ 2 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 1 128 true (1005 ∷ []) (floor 4 1 2 0 ∷ []) true false true 2) (1000 , 2002) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 128 1 true ((1000 , 2002) ∷ []) (2 ∷ [])) +_ : extend (link true 3 255 false ([]) (floor 2 6 2 3 ∷ floor 3 0 2 2 ∷ []) false true true 2) (2000 , 4003) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 255 3 false ((2000 , 4003) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 2 127 false (2002 ∷ []) (floor 4 1 2 3 ∷ floor 5 5 1 3 ∷ []) true false true 2) (1000 , 2006) (valid (route false 122 9 false ((2006 , 2004) ∷ (2004 , 1002) ∷ (1002 , 1000) ∷ []) (1 ∷ 3 ∷ 2 ∷ []))) - ≡ invalid +_ : extend (link true 4 122 true ([]) (floor 1 6 1 3 ∷ []) false true true 3) (2000 , 4001) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 122 4 false ((2000 , 4001) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 3 128 false (1006 ∷ 2003 ∷ []) (floor 2 5 1 0 ∷ floor 2 6 1 3 ∷ []) false true true 1) (1000 , 2002) (valid (route false 128 1 false ((2002 , 2004) ∷ (2004 , 1002) ∷ (1002 , 1006) ∷ (1006 , 1005) ∷ []) (3 ∷ 2 ∷ 2 ∷ 3 ∷ []))) +_ : extend (link true 4 255 false (4001 ∷ []) ([]) true false true 2) (2000 , 4002) (valid (route tt false 122 9 true ((4002 , 4000) ∷ (4000 , 2003) ∷ []) (1 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 0 false ([]) ([]) false false true 2) (1000 , 2001) (valid (route false 255 11 true ((2001 , 1001) ∷ (1001 , 1002) ∷ (1002 , 2003) ∷ (2003 , 1005) ∷ []) (1 ∷ 3 ∷ 1 ∷ 2 ∷ []))) - ≡ valid (route false 255 14 true ((1000 , 2001) ∷ (2001 , 1001) ∷ (1001 , 1002) ∷ (1002 , 2003) ∷ (2003 , 1005) ∷ []) (2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 3 128 false (4005 ∷ []) (floor 1 1 2 2 ∷ floor 1 3 2 3 ∷ floor 6 1 1 1 ∷ []) true false true 1) (2000 , 4004) (valid (route tt false 0 1 true ((4004 , 4003) ∷ (4003 , 2006) ∷ (2006 , 4005) ∷ (4005 , 5005) ∷ []) (1 ∷ 2 ∷ 3 ∷ 0 ∷ []))) + ≡ valid (route tt true 128 4 true ((2000 , 4004) ∷ (4004 , 4003) ∷ (4003 , 2006) ∷ (2006 , 4005) ∷ (4005 , 5005) ∷ []) (1 ∷ 1 ∷ 2 ∷ 3 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 2 0 false (2006 ∷ []) (floor 4 0 2 0 ∷ floor 5 6 2 2 ∷ []) false true true 1) (1000 , 1002) (valid (route true 0 5 false ((1002 , 1003) ∷ (1003 , 2002) ∷ (2002 , 2005) ∷ (2005 , 1006) ∷ []) (3 ∷ 1 ∷ 2 ∷ 3 ∷ []))) - ≡ valid (route true 0 7 false ((1000 , 1002) ∷ (1002 , 1003) ∷ (1003 , 2002) ∷ (2002 , 2005) ∷ (2005 , 1006) ∷ []) (1 ∷ 3 ∷ 1 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 1 128 true ([]) (floor 1 4 2 2 ∷ floor 3 6 2 2 ∷ []) false true true 1) (2000 , 2002) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 128 1 false ((2000 , 2002) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 128 false ([]) (floor 3 5 2 3 ∷ floor 5 1 1 0 ∷ []) true false true 2) (1000 , 2005) (valid (route false 128 10 true ((2005 , 1000) ∷ (1000 , 1004) ∷ (1004 , 2001) ∷ (2001 , 1002) ∷ []) (1 ∷ 2 ∷ 1 ∷ 1 ∷ []))) +_ : extend (link true 2 255 true ([]) (floor 1 2 1 1 ∷ floor 3 6 1 0 ∷ floor 6 3 1 3 ∷ []) true false false 3) (2000 , 4001) (valid (route tt false 127 0 false ((4001 , 4002) ∷ (4002 , 4000) ∷ (4000 , 2005) ∷ (2005 , 3005) ∷ []) (3 ∷ 2 ∷ 1 ∷ 0 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 0 false ([]) (floor 0 3 1 3 ∷ floor 4 1 2 2 ∷ floor 5 0 1 1 ∷ []) false false true 3) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 0 1 false ((1000 , 2004) ∷ []) (3 ∷ [])) +_ : extend (link true 1 128 true (2005 ∷ []) (floor 4 1 1 0 ∷ floor 4 6 1 2 ∷ []) true false false 1) (2000 , 4001) (valid (route tt false 122 7 false ((4001 , 4005) ∷ []) (1 ∷ []))) + ≡ valid (route tt true 128 8 true ((2000 , 4001) ∷ (4001 , 4005) ∷ []) (1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 122 false (2001 ∷ []) ([]) false false true 1) (1000 , 2004) (valid (route true 0 4 false ((2004 , 1002) ∷ (1002 , 1001) ∷ (1001 , 2003) ∷ []) (2 ∷ 3 ∷ 3 ∷ []))) - ≡ valid (route true 122 5 false ((1000 , 2004) ∷ (2004 , 1002) ∷ (1002 , 1001) ∷ (1001 , 2003) ∷ []) (1 ∷ 2 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 4 0 true (4005 ∷ []) (floor 2 6 1 1 ∷ floor 3 3 1 0 ∷ floor 6 1 2 1 ∷ []) false true false 3) (2000 , 4002) (valid (route tt false 255 9 false ((4002 , 2003) ∷ (2003 , 4001) ∷ []) (1 ∷ 2 ∷ []))) + ≡ valid (route tt true 255 13 false ((2000 , 4002) ∷ (4002 , 2003) ∷ (2003 , 4001) ∷ []) (3 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 122 false (1001 ∷ []) (floor 2 2 1 0 ∷ floor 4 0 1 3 ∷ floor 6 3 2 2 ∷ []) false false true 2) (1000 , 1002) (valid (route false 128 2 false ((1002 , 2002) ∷ (2002 , 1004) ∷ (1004 , 1003) ∷ (1003 , 1005) ∷ []) (1 ∷ 2 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route false 128 5 false ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 1004) ∷ (1004 , 1003) ∷ (1003 , 1005) ∷ []) (2 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ [])) -_ = refl - -_ : extend (link true 3 122 true (1004 ∷ []) ([]) true true true 1) (1000 , 1002) (valid (route false 122 2 true ((1002 , 2002) ∷ []) (1 ∷ []))) +_ : extend (link true 3 128 true ([]) (floor 1 2 2 0 ∷ floor 6 2 2 1 ∷ []) false false true 3) (2000 , 2004) (valid (route tt false 0 9 true ((2004 , 4001) ∷ (4001 , 2006) ∷ (2006 , 2002) ∷ []) (3 ∷ 1 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 127 false (2002 ∷ 2006 ∷ []) ([]) false true true 3) (1000 , 1002) (valid (route false 128 10 false ((1002 , 1003) ∷ (1003 , 1004) ∷ []) (3 ∷ 2 ∷ []))) - ≡ valid (route false 128 11 false ((1000 , 1002) ∷ (1002 , 1003) ∷ (1003 , 1004) ∷ []) (3 ∷ 3 ∷ 2 ∷ [])) +_ : extend (link true 1 128 false ([]) ([]) false false false 2) (2000 , 4004) (valid (route tt false 0 0 true ((4004 , 5004) ∷ []) (0 ∷ []))) + ≡ valid (route tt false 128 1 true ((2000 , 4004) ∷ (4004 , 5004) ∷ []) (2 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 3 0 false (2003 ∷ []) (floor 3 2 2 1 ∷ floor 5 3 2 0 ∷ []) false true true 3) (1000 , 2004) (valid (route false 255 0 true ((2004 , 2005) ∷ []) (1 ∷ []))) - ≡ invalid +_ : extend (link true 2 122 false (4003 ∷ []) (floor 4 5 2 0 ∷ []) true false false 3) (2000 , 4004) (valid (route tt true 127 1 false ((4004 , 2005) ∷ []) (1 ∷ []))) + ≡ valid (route tt true 127 3 true ((2000 , 4004) ∷ (4004 , 2005) ∷ []) (3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 3 127 false (2004 ∷ []) (floor 4 1 2 0 ∷ []) false true true 1) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 127 3 false ((1000 , 2001) ∷ []) (1 ∷ [])) +_ : extend (link true 3 0 false (2006 ∷ []) (floor 1 1 1 2 ∷ floor 6 1 1 0 ∷ floor 6 6 1 0 ∷ []) false false true 1) (2000 , 2002) (valid (route tt false 122 8 true ((2002 , 4005) ∷ []) (3 ∷ []))) + ≡ valid (route tt false 122 11 true ((2000 , 2002) ∷ (2002 , 4005) ∷ []) (1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 2 128 false ([]) (floor 0 4 1 1 ∷ []) true true true 2) (1000 , 1004) (valid (route false 127 10 true ((1004 , 2006) ∷ (2006 , 1000) ∷ (1000 , 2003) ∷ []) (1 ∷ 1 ∷ 3 ∷ []))) +_ : extend (link true 4 128 false ([]) (floor 4 5 1 0 ∷ []) true false false 3) (2000 , 2002) (valid (route tt true 122 11 false ((2002 , 4006) ∷ (4006 , 2003) ∷ (2003 , 2000) ∷ (2000 , 2005) ∷ []) (1 ∷ 3 ∷ 2 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 127 false (2005 ∷ []) (floor 3 0 1 2 ∷ []) false false true 3) (1000 , 2004) (valid (route true 122 5 false ((2004 , 2002) ∷ (2002 , 2001) ∷ (2001 , 1003) ∷ (1003 , 1005) ∷ []) (2 ∷ 1 ∷ 2 ∷ 3 ∷ []))) - ≡ valid (route true 127 6 false ((1000 , 2004) ∷ (2004 , 2002) ∷ (2002 , 2001) ∷ (2001 , 1003) ∷ (1003 , 1005) ∷ []) (3 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 2 122 true (2002 ∷ []) (floor 1 2 2 3 ∷ floor 1 3 1 1 ∷ floor 3 3 2 2 ∷ []) false true true 2) (2000 , 2002) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 122 2 false ((2000 , 2002) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 4 128 true ([]) (floor 0 1 2 3 ∷ floor 6 4 2 1 ∷ []) false false true 1) (1000 , 2002) (valid (route true 128 5 false ((2002 , 2031) ∷ (2031 , 1010) ∷ (1010 , 2011) ∷ (2011 , 1027) ∷ (1027 , 2022) ∷ (2022 , 1040) ∷ (1040 , 1029) ∷ (1029 , 1020) ∷ (1020 , 1017) ∷ (1017 , 1001) ∷ (1001 , 1007) ∷ (1007 , 1037) ∷ (1037 , 2019) ∷ (2019 , 2015) ∷ (2015 , 2039) ∷ (2039 , 2026) ∷ (2026 , 2016) ∷ (2016 , 1013) ∷ (1013 , 1002) ∷ (1002 , 2038) ∷ (2038 , 1008) ∷ (1008 , 2018) ∷ (2018 , 2036) ∷ (2036 , 2014) ∷ (2014 , 1004) ∷ (1004 , 2033) ∷ (2033 , 2003) ∷ (2003 , 1034) ∷ (1034 , 2032) ∷ (2032 , 1023) ∷ (1023 , 1009) ∷ []) (3 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ []))) - ≡ invalid +_ : extend (link true 4 128 false (4004 ∷ 2005 ∷ []) ([]) false false true 1) (2000 , 2005) (valid (route tt false 128 3 false ((2005 , 2001) ∷ (2001 , 4006) ∷ (4006 , 4003) ∷ (4003 , 2004) ∷ []) (3 ∷ 1 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route tt true 128 7 false ((2000 , 2005) ∷ (2005 , 2001) ∷ (2001 , 4006) ∷ (4006 , 4003) ∷ (4003 , 2004) ∷ []) (1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 127 false (1003 ∷ 1006 ∷ []) (floor 4 5 2 3 ∷ floor 6 5 1 2 ∷ []) false false false 3) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) - ≡ invalid +_ : extend (link true 1 255 false ([]) (floor 4 4 1 1 ∷ []) false false true 1) (2000 , 4003) (valid (route tt false 122 1 true ((4003 , 2004) ∷ (2004 , 2002) ∷ []) (1 ∷ 1 ∷ []))) + ≡ valid (route tt false 255 2 true ((2000 , 4003) ∷ (4003 , 2004) ∷ (2004 , 2002) ∷ []) (1 ∷ 1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 128 false (1003 ∷ []) ([]) false false true 3) (1000 , 1001) (valid (route false 0 0 false ((1001 , 2006) ∷ (2006 , 2005) ∷ (2005 , 1004) ∷ (1004 , 2002) ∷ []) (1 ∷ 3 ∷ 3 ∷ 3 ∷ []))) - ≡ valid (route false 128 2 false ((1000 , 1001) ∷ (1001 , 2006) ∷ (2006 , 2005) ∷ (2005 , 1004) ∷ (1004 , 2002) ∷ []) (3 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 2 122 false ([]) ([]) false false true 1) (2000 , 4005) (valid (route tt false 128 3 true ((4005 , 2002) ∷ (2002 , 2004) ∷ []) (1 ∷ 3 ∷ []))) + ≡ valid (route tt false 128 5 true ((2000 , 4005) ∷ (4005 , 2002) ∷ (2002 , 2004) ∷ []) (1 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 0 true ([]) ([]) false true false 3) (1000 , 1004) (valid (route false 0 0 false ([]) ([]))) - ≡ invalid +_ : extend (link true 4 255 true (4005 ∷ []) (floor 2 0 2 3 ∷ floor 2 2 1 3 ∷ floor 4 0 1 1 ∷ []) false false true 1) (2000 , 2006) (valid (route tt false 0 0 true ((2006 , 3006) ∷ []) (0 ∷ []))) + ≡ valid (route tt true 255 4 true ((2000 , 2006) ∷ (2006 , 3006) ∷ []) (1 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 4 122 false ([]) (floor 2 2 2 1 ∷ floor 6 2 2 0 ∷ []) false false false 3) (1000 , 2001) (valid (route false 122 0 true ((2001 , 1001) ∷ (1001 , 1006) ∷ (1006 , 1002) ∷ []) (1 ∷ 2 ∷ 3 ∷ []))) +_ : extend (link true 2 255 true ([]) (floor 2 2 2 1 ∷ []) true false false 2) (2000 , 2002) (valid (route tt false 128 3 false ((2002 , 2006) ∷ (2006 , 4001) ∷ (4001 , 4000) ∷ []) (3 ∷ 2 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 0 true (2003 ∷ 2005 ∷ []) (floor 1 1 1 0 ∷ floor 6 5 2 1 ∷ []) false true true 2) (1000 , 2004) (valid (route false 128 7 false ((2004 , 1004) ∷ []) (1 ∷ []))) - ≡ valid (route true 128 10 false ((1000 , 2004) ∷ (2004 , 1004) ∷ []) (2 ∷ 1 ∷ [])) +_ : extend (link true 3 127 true ([]) (floor 5 2 1 1 ∷ []) true false true 3) (2000 , 4002) (valid (route tt true 0 3 true ((4002 , 4001) ∷ (4001 , 4003) ∷ (4003 , 2005) ∷ (2005 , 2000) ∷ []) (2 ∷ 1 ∷ 3 ∷ 3 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 1 127 false ([]) (floor 6 0 2 2 ∷ floor 6 6 2 1 ∷ []) false true true 3) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 127 1 false ((1000 , 1003) ∷ []) (3 ∷ [])) +_ : extend (link true 2 122 false ([]) (floor 2 5 2 3 ∷ floor 6 4 1 2 ∷ floor 6 5 2 2 ∷ []) true false false 1) (2000 , 4006) (valid (route tt false 0 0 false ([]) ([]))) + ≡ invalid _ = refl -_ : extend (link true 4 127 false (2005 ∷ []) ([]) true true true 1) (1000 , 2005) (valid (route false 122 4 false ((2005 , 2003) ∷ []) (2 ∷ []))) - ≡ valid (route true 127 8 true ((1000 , 2005) ∷ (2005 , 2003) ∷ []) (1 ∷ 2 ∷ [])) +_ : extend (link true 2 122 false (2004 ∷ 2005 ∷ []) (floor 1 4 1 2 ∷ floor 4 4 2 3 ∷ floor 4 6 2 3 ∷ []) false false true 2) (2000 , 4005) (valid (route tt false 0 3 false ((4005 , 2006) ∷ (2006 , 4004) ∷ []) (2 ∷ 1 ∷ []))) + ≡ valid (route tt false 122 5 false ((2000 , 4005) ∷ (4005 , 2006) ∷ (2006 , 4004) ∷ []) (2 ∷ 2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 122 false ([]) (floor 0 2 1 0 ∷ floor 1 4 1 2 ∷ []) false false true 3) (1000 , 1001) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 122 1 false ((1000 , 1001) ∷ []) (3 ∷ [])) +_ : extend (link true 1 128 true ([]) (floor 1 4 2 1 ∷ floor 4 0 1 3 ∷ []) false true false 3) (2000 , 4006) (valid (route tt false 128 5 false ((4006 , 4005) ∷ (4005 , 4003) ∷ []) (2 ∷ 2 ∷ []))) + ≡ valid (route tt true 128 6 false ((2000 , 4006) ∷ (4006 , 4005) ∷ (4005 , 4003) ∷ []) (3 ∷ 2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 122 false (2006 ∷ []) ([]) false false true 1) (1000 , 2003) (valid (route false 127 5 false ((2003 , 1004) ∷ (1004 , 2006) ∷ []) (3 ∷ 3 ∷ []))) - ≡ valid (route true 127 6 false ((1000 , 2003) ∷ (2003 , 1004) ∷ (1004 , 2006) ∷ []) (1 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 4 122 true (2003 ∷ 2005 ∷ []) (floor 1 1 1 2 ∷ floor 6 3 1 3 ∷ []) false false true 3) (2000 , 4002) (valid (route tt true 128 5 false ((4002 , 4003) ∷ []) (2 ∷ []))) + ≡ valid (route tt true 128 9 false ((2000 , 4002) ∷ (4002 , 4003) ∷ []) (3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 122 false ([]) (floor 3 6 1 3 ∷ []) false true true 3) (1000 , 1005) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 122 1 false ((1000 , 1005) ∷ []) (3 ∷ [])) +_ : extend (link true 1 127 true (2001 ∷ []) (floor 1 1 1 3 ∷ floor 3 0 2 3 ∷ floor 4 0 2 3 ∷ []) true false true 2) (2000 , 4006) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 127 1 true ((2000 , 4006) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 1 122 false ([]) ([]) false false true 1) (1000 , 2004) (valid (route false 127 4 false ((2004 , 2005) ∷ (2005 , 2002) ∷ (2002 , 1006) ∷ []) (1 ∷ 2 ∷ 2 ∷ []))) - ≡ valid (route false 127 5 false ((1000 , 2004) ∷ (2004 , 2005) ∷ (2005 , 2002) ∷ (2002 , 1006) ∷ []) (1 ∷ 1 ∷ 2 ∷ 2 ∷ [])) +_ : extend (link true 1 127 true (2001 ∷ 4006 ∷ []) (floor 3 2 1 1 ∷ floor 4 5 2 2 ∷ floor 5 0 1 3 ∷ []) false true true 2) (2000 , 2005) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 127 1 false ((2000 , 2005) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 3 127 false ([]) ([]) false false false 1) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) - ≡ invalid +_ : extend (link true 3 122 false (2002 ∷ 2004 ∷ []) (floor 1 4 2 2 ∷ floor 6 5 1 2 ∷ []) true false true 3) (2000 , 4001) (valid (route tt false 255 10 false ((4001 , 2005) ∷ []) (2 ∷ []))) + ≡ valid (route tt false 255 13 true ((2000 , 4001) ∷ (4001 , 2005) ∷ []) (3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 127 true ([]) (floor 2 0 2 0 ∷ floor 5 2 1 2 ∷ []) true false true 3) (1000 , 2006) (valid (route false 128 8 false ((2006 , 2002) ∷ (2002 , 1004) ∷ []) (2 ∷ 1 ∷ []))) - ≡ valid (route true 128 9 true ((1000 , 2006) ∷ (2006 , 2002) ∷ (2002 , 1004) ∷ []) (3 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 2 122 false ([]) (floor 3 4 2 1 ∷ floor 6 2 1 0 ∷ []) true false true 3) (2000 , 2002) (valid (route tt false 127 10 false ((2002 , 4003) ∷ (4003 , 2004) ∷ []) (3 ∷ 3 ∷ []))) + ≡ valid (route tt false 127 12 true ((2000 , 2002) ∷ (2002 , 4003) ∷ (4003 , 2004) ∷ []) (3 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 128 false (2002 ∷ []) (floor 2 4 2 3 ∷ floor 5 5 2 3 ∷ []) false true true 3) (1000 , 1004) (valid (route false 128 8 true ((1004 , 2004) ∷ (2004 , 1006) ∷ []) (1 ∷ 3 ∷ []))) +_ : extend (link true 3 122 true (4001 ∷ 4002 ∷ []) (floor 4 5 2 3 ∷ floor 4 6 2 2 ∷ floor 6 5 2 3 ∷ []) true false true 3) (2000 , 2005) (valid (route tt false 0 6 false ((2005 , 4000) ∷ (4000 , 4003) ∷ []) (2 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 127 false (2006 ∷ []) ([]) false true true 1) (1000 , 1003) (valid (route false 0 6 true ((1003 , 1005) ∷ (1005 , 2002) ∷ (2002 , 1006) ∷ (1006 , 1001) ∷ []) (1 ∷ 2 ∷ 1 ∷ 2 ∷ []))) - ≡ invalid +_ : extend (link true 2 128 false ([]) ([]) false false false 1) (2000 , 4001) (valid (route tt true 122 9 false ((4001 , 4003) ∷ (4003 , 2005) ∷ (2005 , 2002) ∷ []) (3 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route tt true 128 11 false ((2000 , 4001) ∷ (4001 , 4003) ∷ (4003 , 2005) ∷ (2005 , 2002) ∷ []) (1 ∷ 3 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 255 false ([]) (floor 2 6 2 1 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 255 4 false ((1000 , 1002) ∷ []) (2 ∷ [])) +_ : extend (link true 4 0 true (2003 ∷ 4005 ∷ []) (floor 2 2 2 0 ∷ floor 6 4 2 1 ∷ []) false false true 2) (2000 , 2006) (valid (route tt false 127 10 true ((2006 , 4001) ∷ (4001 , 4003) ∷ []) (1 ∷ 2 ∷ []))) + ≡ valid (route tt true 127 14 true ((2000 , 2006) ∷ (2006 , 4001) ∷ (4001 , 4003) ∷ []) (2 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 4 128 false (1003 ∷ 1006 ∷ []) (floor 0 4 1 0 ∷ floor 4 0 2 2 ∷ floor 4 1 1 1 ∷ []) false false true 1) (1000 , 1005) (valid (route false 0 6 false ((1005 , 2002) ∷ (2002 , 2001) ∷ (2001 , 2006) ∷ (2006 , 2004) ∷ []) (2 ∷ 3 ∷ 1 ∷ 2 ∷ []))) - ≡ valid (route false 128 10 false ((1000 , 1005) ∷ (1005 , 2002) ∷ (2002 , 2001) ∷ (2001 , 2006) ∷ (2006 , 2004) ∷ []) (1 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 3 128 false (2004 ∷ 4006 ∷ []) ([]) false false false 2) (2000 , 4004) (valid (route tt false 0 4 false ((4004 , 4003) ∷ (4003 , 4005) ∷ []) (3 ∷ 2 ∷ []))) + ≡ valid (route tt false 128 7 false ((2000 , 4004) ∷ (4004 , 4003) ∷ (4003 , 4005) ∷ []) (2 ∷ 3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 127 false (1004 ∷ 2002 ∷ []) (floor 0 6 1 1 ∷ floor 2 6 2 1 ∷ floor 3 6 1 0 ∷ []) true true true 2) (1000 , 1003) (valid (route false 127 7 true ((1003 , 1000) ∷ (1000 , 1004) ∷ []) (1 ∷ 2 ∷ []))) +_ : extend (link true 2 255 false (4006 ∷ []) (floor 2 5 1 1 ∷ floor 6 1 2 1 ∷ floor 6 5 2 0 ∷ []) false true true 2) (2000 , 2003) (valid (route tt false 0 0 true ((2003 , 3003) ∷ []) (0 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 127 false (2005 ∷ []) ([]) false true true 3) (1000 , 2006) (valid (route false 255 0 false ((2006 , 2004) ∷ (2004 , 1006) ∷ []) (2 ∷ 3 ∷ []))) - ≡ valid (route false 255 4 false ((1000 , 2006) ∷ (2006 , 2004) ∷ (2004 , 1006) ∷ []) (3 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 2 128 false (2002 ∷ 2006 ∷ []) (floor 3 6 1 1 ∷ floor 4 6 1 1 ∷ floor 6 6 2 3 ∷ []) false false false 1) (2000 , 2002) (valid (route tt false 255 8 false ((2002 , 4005) ∷ (4005 , 5005) ∷ []) (2 ∷ 0 ∷ []))) + ≡ valid (route tt true 255 10 false ((2000 , 2002) ∷ (2002 , 4005) ∷ (4005 , 5005) ∷ []) (1 ∷ 2 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 4 0 false ([]) (floor 0 0 2 0 ∷ floor 2 6 2 0 ∷ floor 3 3 2 1 ∷ []) true false true 1) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 0 4 true ((1000 , 2001) ∷ []) (1 ∷ [])) +_ : extend (link true 4 128 false (4005 ∷ 4006 ∷ []) (floor 1 2 1 3 ∷ floor 2 3 1 3 ∷ []) false false false 1) (2000 , 4001) (valid (route tt false 0 5 false ((4001 , 2002) ∷ (2002 , 2004) ∷ []) (3 ∷ 1 ∷ []))) + ≡ valid (route tt false 128 9 false ((2000 , 4001) ∷ (4001 , 2002) ∷ (2002 , 2004) ∷ []) (1 ∷ 3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 122 true (1005 ∷ 2006 ∷ []) (floor 1 2 1 1 ∷ floor 6 6 2 0 ∷ []) false false true 3) (1000 , 1003) (valid (route true 128 5 false ((1003 , 1004) ∷ []) (2 ∷ []))) - ≡ valid (route true 128 9 false ((1000 , 1003) ∷ (1003 , 1004) ∷ []) (3 ∷ 2 ∷ [])) +_ : extend (link true 4 128 false ([]) (floor 2 4 1 0 ∷ floor 3 3 2 0 ∷ floor 6 5 2 3 ∷ []) true false true 2) (2000 , 4001) (valid (route tt false 128 1 false ((4001 , 2002) ∷ (2002 , 3002) ∷ []) (1 ∷ 0 ∷ []))) + ≡ valid (route tt false 128 5 true ((2000 , 4001) ∷ (4001 , 2002) ∷ (2002 , 3002) ∷ []) (2 ∷ 1 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 1 127 true (1003 ∷ []) (floor 0 1 1 3 ∷ floor 1 0 2 3 ∷ floor 6 0 2 3 ∷ []) true false true 2) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 127 1 true ((1000 , 2004) ∷ []) (2 ∷ [])) +_ : extend (link true 1 127 false (2003 ∷ []) (floor 1 4 1 2 ∷ floor 3 2 2 2 ∷ floor 5 2 2 3 ∷ []) false false false 3) (2000 , 2002) (valid (route tt false 127 3 true ((2002 , 2005) ∷ (2005 , 2006) ∷ (2006 , 4003) ∷ (4003 , 4001) ∷ []) (3 ∷ 3 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route tt false 127 4 true ((2000 , 2002) ∷ (2002 , 2005) ∷ (2005 , 2006) ∷ (2006 , 4003) ∷ (4003 , 4001) ∷ []) (3 ∷ 3 ∷ 3 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 127 true (1003 ∷ 2004 ∷ []) (floor 1 0 1 3 ∷ floor 5 2 1 1 ∷ floor 6 5 2 2 ∷ []) false true true 2) (1000 , 1005) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 127 1 false ((1000 , 1005) ∷ []) (2 ∷ [])) +_ : extend (link true 1 255 false ([]) (floor 1 5 1 1 ∷ floor 6 5 1 0 ∷ []) false false true 2) (2000 , 4006) (valid (route tt false 255 8 false ((4006 , 4002) ∷ []) (2 ∷ []))) + ≡ valid (route tt false 255 9 false ((2000 , 4006) ∷ (4006 , 4002) ∷ []) (2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 2 0 true (2001 ∷ 2005 ∷ []) (floor 2 4 2 2 ∷ floor 4 5 1 2 ∷ []) true false true 2) (1000 , 1004) (valid (route true 255 11 false ((1004 , 1005) ∷ []) (3 ∷ []))) - ≡ valid (route true 255 13 true ((1000 , 1004) ∷ (1004 , 1005) ∷ []) (2 ∷ 3 ∷ [])) +_ : extend (link true 1 122 false (4004 ∷ []) (floor 1 1 2 3 ∷ floor 2 4 1 3 ∷ floor 4 2 2 0 ∷ []) false true false 3) (2000 , 2003) (valid (route tt false 127 10 true ((2003 , 2006) ∷ (2006 , 2001) ∷ (2001 , 3001) ∷ []) (1 ∷ 1 ∷ 0 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 2 0 false (2002 ∷ []) (floor 1 6 2 0 ∷ floor 5 0 2 1 ∷ []) true false true 2) (1000 , 1006) (valid (route false 127 9 true ((1006 , 1004) ∷ (1004 , 1001) ∷ (1001 , 1002) ∷ (1002 , 2005) ∷ []) (2 ∷ 2 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route false 127 11 true ((1000 , 1006) ∷ (1006 , 1004) ∷ (1004 , 1001) ∷ (1001 , 1002) ∷ (1002 , 2005) ∷ []) (2 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 3 122 false ([]) (floor 1 6 2 0 ∷ floor 2 5 2 0 ∷ floor 3 6 1 3 ∷ []) false false true 3) (2000 , 2001) (valid (route tt false 0 0 true ((2001 , 3001) ∷ []) (0 ∷ []))) + ⊕ extend (link true 3 122 false ([]) (floor 1 6 2 0 ∷ floor 2 5 2 0 ∷ floor 3 6 1 3 ∷ []) false false true 3) (2000 , 4005) (valid (route tt false 0 0 true ((4005 , 5005) ∷ []) (0 ∷ []))) + ≡ valid (route tt false 122 3 true ((2000 , 2001) ∷ (2001 , 3001) ∷ []) (3 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 4 127 false (1004 ∷ []) (floor 0 4 2 3 ∷ floor 1 3 1 0 ∷ floor 6 6 2 0 ∷ []) false false true 2) (1000 , 1005) (valid (route true 128 8 false ((1005 , 2012) ∷ (2012 , 2029) ∷ (2029 , 2039) ∷ (2039 , 2028) ∷ (2028 , 2040) ∷ (2040 , 2011) ∷ (2011 , 2003) ∷ (2003 , 1024) ∷ (1024 , 2014) ∷ (2014 , 2002) ∷ (2002 , 2008) ∷ (2008 , 2015) ∷ (2015 , 1026) ∷ (1026 , 2007) ∷ (2007 , 1009) ∷ (1009 , 1038) ∷ (1038 , 2034) ∷ (2034 , 1022) ∷ (1022 , 2036) ∷ (2036 , 1001) ∷ (1001 , 2025) ∷ (2025 , 2020) ∷ (2020 , 1018) ∷ (1018 , 1013) ∷ (1013 , 1017) ∷ (1017 , 2023) ∷ (2023 , 1035) ∷ (1035 , 1027) ∷ (1027 , 2005) ∷ (2005 , 2016) ∷ (2016 , 1019) ∷ (1019 , 2004) ∷ []) (1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ []))) - ≡ invalid +_ : extend (link true 4 128 false (2001 ∷ []) ([]) false false false 2) (2000 , 2002) (valid (route tt false 255 10 false ((2002 , 2003) ∷ (2003 , 2000) ∷ (2000 , 2004) ∷ []) (2 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 2 0 false (2001 ∷ []) ([]) true false true 3) (2000 , 2005) (valid (route tt false 128 0 false ((2005 , 2003) ∷ []) (3 ∷ []))) + ≡ valid (route tt false 128 2 true ((2000 , 2005) ∷ (2005 , 2003) ∷ []) (3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 2 128 false (2004 ∷ []) (floor 0 1 1 3 ∷ floor 0 5 2 2 ∷ []) false false false 1) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) +_ : extend (link true 1 127 false (2003 ∷ 4006 ∷ []) (floor 6 1 1 2 ∷ floor 6 3 1 1 ∷ floor 6 6 2 3 ∷ []) false false true 2) (2000 , 2001) (valid (route tt false 122 4 false ((2001 , 4000) ∷ (4000 , 4003) ∷ []) (1 ∷ 3 ∷ []))) + ⊕ extend (link true 1 127 false (2003 ∷ 4006 ∷ []) (floor 6 1 1 2 ∷ floor 6 3 1 1 ∷ floor 6 6 2 3 ∷ []) true false true 2) (2000 , 2002) (valid (route tt false 122 4 false ((2002 , 4000) ∷ (4000 , 4003) ∷ []) (1 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 127 false (1004 ∷ 2002 ∷ []) (floor 0 2 1 3 ∷ floor 3 3 1 3 ∷ []) true false false 3) (1000 , 1006) (valid (route false 122 8 false ((1006 , 1002) ∷ (1002 , 1004) ∷ []) (2 ∷ 1 ∷ []))) - ≡ valid (route true 127 9 true ((1000 , 1006) ∷ (1006 , 1002) ∷ (1002 , 1004) ∷ []) (3 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 3 122 true (4002 ∷ []) (floor 2 5 2 3 ∷ floor 6 6 1 1 ∷ []) false true true 3) (2000 , 4006) (valid (route tt false 127 5 true ((4006 , 2003) ∷ (2003 , 4005) ∷ (4005 , 4002) ∷ []) (1 ∷ 1 ∷ 2 ∷ []))) + ⊕ extend (link true 3 122 true (4002 ∷ []) (floor 2 5 2 3 ∷ floor 6 6 1 1 ∷ []) false true true 3) (2000 , 4005) (valid (route tt false 127 5 true ((4005 , 2003) ∷ (2003 , 4005) ∷ (4005 , 4002) ∷ []) (1 ∷ 1 ∷ 2 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 1 127 false (1005 ∷ 2003 ∷ []) ([]) false false true 1) (1000 , 2003) (valid (route true 255 3 false ((2003 , 1006) ∷ (1006 , 2002) ∷ []) (2 ∷ 3 ∷ []))) - ≡ valid (route true 255 4 false ((1000 , 2003) ∷ (2003 , 1006) ∷ (1006 , 2002) ∷ []) (1 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 4 128 false (4005 ∷ []) (floor 2 3 1 1 ∷ floor 3 3 1 0 ∷ []) true false true 2) (2000 , 4002) (valid (route tt true 128 0 true ((4002 , 2004) ∷ (2004 , 2001) ∷ (2001 , 2003) ∷ (2003 , 4000) ∷ []) (2 ∷ 2 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 4 128 false (4005 ∷ []) (floor 2 3 1 1 ∷ floor 3 3 1 0 ∷ []) true false true 2) (2000 , 2006) (valid (route tt true 128 0 true ((2006 , 2004) ∷ (2004 , 2001) ∷ (2001 , 2003) ∷ (2003 , 4000) ∷ []) (2 ∷ 2 ∷ 2 ∷ 1 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 3 128 false (1006 ∷ []) (floor 2 1 1 3 ∷ floor 2 6 2 1 ∷ []) false false false 1) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) +_ : extend (link true 1 127 false (4004 ∷ []) (floor 2 0 1 3 ∷ floor 3 5 1 1 ∷ []) false true true 2) (2000 , 2003) (valid (route tt false 128 8 true ((2003 , 4005) ∷ (4005 , 4004) ∷ []) (3 ∷ 1 ∷ []))) + ⊕ extend (link true 1 127 false (4004 ∷ []) (floor 2 0 1 3 ∷ floor 3 5 1 1 ∷ []) true true true 2) (2000 , 4006) (valid (route tt false 128 8 true ((4006 , 4005) ∷ (4005 , 4004) ∷ []) (3 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 122 false (2001 ∷ []) (floor 2 6 2 3 ∷ []) false true true 1) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 122 1 false ((1000 , 2003) ∷ []) (1 ∷ [])) +_ : extend (link true 3 128 false ([]) (floor 4 0 2 2 ∷ floor 5 2 2 3 ∷ []) false true true 2) (2000 , 2003) (valid (route tt false 128 0 false ((2003 , 2001) ∷ (2001 , 2005) ∷ []) (2 ∷ 1 ∷ []))) + ⊕ extend (link true 3 128 false ([]) (floor 4 0 2 2 ∷ floor 5 2 2 3 ∷ []) false true true 2) (2000 , 2004) (valid (route tt false 128 0 false ((2004 , 2001) ∷ (2001 , 2005) ∷ []) (2 ∷ 1 ∷ []))) + ≡ valid (route tt false 128 3 false ((2000 , 2003) ∷ (2003 , 2001) ∷ (2001 , 2005) ∷ []) (2 ∷ 2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 3 127 true ([]) (floor 1 0 1 3 ∷ []) true false true 2) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 127 3 true ((1000 , 1006) ∷ []) (2 ∷ [])) +_ : extend (link true 1 122 false ([]) (floor 1 1 2 3 ∷ floor 6 2 1 0 ∷ []) false false false 3) (2000 , 2002) (valid (route tt false 0 3 false ((2002 , 4006) ∷ []) (2 ∷ []))) + ⊕ extend (link true 4 0 false ([]) (floor 1 1 2 3 ∷ floor 6 2 1 0 ∷ []) false false true 1) (2000 , 2003) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 4 false ((2000 , 2003) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 1 127 false ([]) ([]) true false true 2) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 127 1 true ((1000 , 2006) ∷ []) (2 ∷ [])) +_ : extend (link true 4 122 false (2002 ∷ 4002 ∷ []) (floor 3 1 2 1 ∷ floor 6 1 1 3 ∷ []) false true true 3) (2000 , 4003) (valid (route tt false 255 5 false ((4003 , 2004) ∷ (2004 , 2006) ∷ []) (3 ∷ 1 ∷ []))) + ⊕ extend (link true 4 122 false (2002 ∷ 4002 ∷ []) (floor 3 1 2 1 ∷ floor 6 1 1 3 ∷ []) false true true 3) (2000 , 2006) (valid (route tt false 255 5 false ((2006 , 2115) ∷ (2115 , 2004) ∷ (2004 , 2006) ∷ []) (3 ∷ 1 ∷ 1 ∷ []))) + ≡ valid (route tt false 255 9 false ((2000 , 4003) ∷ (4003 , 2004) ∷ (2004 , 2006) ∷ []) (3 ∷ 3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 3 255 true (1002 ∷ []) (floor 4 5 1 1 ∷ []) true false true 3) (1000 , 2001) (valid (route false 122 2 true ((2001 , 1006) ∷ (1006 , 1002) ∷ []) (1 ∷ 2 ∷ []))) - ⊕ extend (link true 1 127 false (1002 ∷ []) (floor 4 5 1 1 ∷ []) false true true 1) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 127 1 false ((1000 , 2004) ∷ []) (1 ∷ [])) +_ : extend (link true 3 0 false (2001 ∷ 2003 ∷ []) (floor 1 1 1 3 ∷ floor 1 5 1 3 ∷ floor 5 4 1 3 ∷ []) false true false 2) (2000 , 2005) (valid (route tt false 0 6 true ((2005 , 4000) ∷ []) (2 ∷ []))) + ⊕ extend (link true 3 0 false (2001 ∷ 2003 ∷ []) (floor 1 1 1 3 ∷ floor 1 5 1 3 ∷ floor 5 4 1 3 ∷ []) false true false 2) (2000 , 4003) (valid (route tt false 0 6 true ((4003 , 4000) ∷ []) (2 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 1 128 false (1005 ∷ 2004 ∷ []) ([]) false false false 1) (1000 , 2006) (valid (route false 127 11 true ((2006 , 1006) ∷ []) (1 ∷ []))) - ⊕ extend (link true 1 128 false (1005 ∷ 2004 ∷ []) ([]) false false false 1) (1000 , 1004) (valid (route false 127 11 true ((1004 , 1006) ∷ []) (1 ∷ []))) - ≡ valid (route false 128 12 true ((1000 , 1004) ∷ (1004 , 1006) ∷ []) (1 ∷ 1 ∷ [])) +_ : extend (link true 4 128 false (4005 ∷ []) ([]) false false true 1) (2000 , 2006) (valid (route tt false 127 1 false ((2006 , 4004) ∷ (4004 , 4005) ∷ []) (3 ∷ 3 ∷ []))) + ⊕ extend (link true 3 127 false (4005 ∷ []) ([]) true true false 3) (2000 , 2001) (valid (route tt false 0 10 false ((2001 , 2004) ∷ (2004 , 2006) ∷ (2006 , 2002) ∷ (2002 , 4003) ∷ []) (3 ∷ 2 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route tt false 127 13 true ((2000 , 2001) ∷ (2001 , 2004) ∷ (2004 , 2006) ∷ (2006 , 2002) ∷ (2002 , 4003) ∷ []) (3 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 0 false (1005 ∷ 2005 ∷ []) ([]) false false true 3) (1000 , 1002) (valid (route false 255 6 false ((1002 , 1000) ∷ []) (2 ∷ []))) - ⊕ extend (link true 4 127 true (1005 ∷ 2005 ∷ []) ([]) false true true 1) (1000 , 1003) (valid (route false 255 4 false ((1003 , 2002) ∷ []) (1 ∷ []))) - ≡ valid (route true 255 8 false ((1000 , 1003) ∷ (1003 , 2002) ∷ []) (1 ∷ 1 ∷ [])) +_ : extend (link true 2 255 false (4005 ∷ []) (floor 1 0 2 1 ∷ []) false false true 1) (2000 , 4006) (valid (route tt false 127 7 false ((4006 , 2005) ∷ (2005 , 3005) ∷ []) (1 ∷ 0 ∷ []))) + ⊕ extend (link true 2 255 false (4005 ∷ []) (floor 1 0 2 1 ∷ []) true false true 1) (2000 , 4005) (valid (route tt false 127 7 false ((4005 , 2005) ∷ (2005 , 3005) ∷ []) (1 ∷ 0 ∷ []))) + ≡ valid (route tt false 255 9 false ((2000 , 4006) ∷ (4006 , 2005) ∷ (2005 , 3005) ∷ []) (1 ∷ 1 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 4 0 false (2002 ∷ []) (floor 0 1 2 0 ∷ floor 6 3 2 0 ∷ []) true false true 2) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 4 0 false (2002 ∷ []) (floor 0 1 2 0 ∷ floor 6 3 2 0 ∷ []) true false true 2) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 0 4 true ((1000 , 2001) ∷ []) (2 ∷ [])) +_ : extend (link true 1 128 false ([]) ([]) false false true 2) (2000 , 4001) (valid (route tt true 122 0 false ((4001 , 2004) ∷ (2004 , 2006) ∷ []) (2 ∷ 3 ∷ []))) + ⊕ extend (link true 1 128 false ([]) ([]) false false true 2) (2000 , 4005) (valid (route tt true 122 0 false ((4005 , 2128) ∷ (2128 , 2004) ∷ (2004 , 2006) ∷ []) (2 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route tt true 128 1 false ((2000 , 4001) ∷ (4001 , 2004) ∷ (2004 , 2006) ∷ []) (2 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 127 false ([]) (floor 2 6 2 3 ∷ floor 5 0 2 2 ∷ []) false false true 2) (1000 , 1001) (valid (route false 122 4 false ((1001 , 1006) ∷ (1006 , 1003) ∷ []) (1 ∷ 3 ∷ []))) - ⊕ extend (link true 4 0 false ([]) (floor 2 6 2 3 ∷ floor 5 0 2 2 ∷ []) false false true 3) (1000 , 2005) (valid (route false 122 2 false ((2005 , 2001) ∷ []) (3 ∷ []))) - ≡ valid (route false 122 6 false ((1000 , 2005) ∷ (2005 , 2001) ∷ []) (3 ∷ 3 ∷ [])) +_ : extend (link true 1 122 false ([]) (floor 2 3 1 0 ∷ floor 2 5 1 2 ∷ floor 3 4 1 1 ∷ []) false true true 3) (2000 , 2004) (valid (route tt false 127 11 true ((2004 , 4005) ∷ []) (2 ∷ []))) + ⊕ extend (link true 1 122 false ([]) (floor 2 3 1 0 ∷ floor 2 5 1 2 ∷ floor 3 4 1 1 ∷ []) false true true 3) (2000 , 4001) (valid (route tt false 127 11 true ((4001 , 4005) ∷ []) (2 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 4 0 false (1001 ∷ 2003 ∷ []) (floor 3 0 2 1 ∷ floor 4 1 1 1 ∷ []) false false true 3) (1000 , 2001) (valid (route true 128 6 false ((2001 , 2003) ∷ []) (3 ∷ []))) - ⊕ extend (link true 4 0 false (1001 ∷ 2003 ∷ []) (floor 3 0 2 1 ∷ floor 4 1 1 1 ∷ []) false false true 3) (1000 , 1002) (valid (route true 128 6 false ((1002 , 2003) ∷ []) (3 ∷ []))) - ≡ valid (route true 128 10 false ((1000 , 2001) ∷ (2001 , 2003) ∷ []) (3 ∷ 3 ∷ [])) +_ : extend (link true 4 255 true (4001 ∷ 2005 ∷ []) ([]) false false true 1) (2000 , 4006) (valid (route tt false 0 0 true ((4006 , 5006) ∷ []) (0 ∷ []))) + ⊕ extend (link true 1 0 false (4001 ∷ 2005 ∷ []) ([]) false false true 3) (2000 , 4004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 1 false ((2000 , 4004) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 1 122 false (2002 ∷ []) (floor 3 0 1 3 ∷ floor 3 6 1 3 ∷ []) true true false 1) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 1 122 false (2002 ∷ []) (floor 3 0 1 3 ∷ floor 3 6 1 3 ∷ []) true true false 1) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) - ≡ invalid +_ : extend (link true 1 128 false (4002 ∷ []) (floor 2 6 2 1 ∷ []) false false true 2) (2000 , 2005) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 1 128 false (4002 ∷ []) (floor 2 6 2 1 ∷ []) true false true 2) (2000 , 4002) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 128 1 false ((2000 , 2005) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 1 255 true (1006 ∷ []) (floor 2 3 1 2 ∷ floor 3 0 2 2 ∷ floor 4 5 1 2 ∷ []) false false true 3) (1000 , 1001) (valid (route false 0 8 true ((1001 , 1002) ∷ (1002 , 1005) ∷ []) (3 ∷ 3 ∷ []))) - ⊕ extend (link true 4 127 false (1006 ∷ []) (floor 2 3 1 2 ∷ floor 3 0 2 2 ∷ floor 4 5 1 2 ∷ []) true false true 2) (1000 , 1004) (valid (route true 128 5 false ((1004 , 2006) ∷ (2006 , 1005) ∷ []) (3 ∷ 3 ∷ []))) - ≡ valid (route true 128 9 true ((1000 , 1004) ∷ (1004 , 2006) ∷ (2006 , 1005) ∷ []) (2 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 3 0 false (4001 ∷ 2003 ∷ []) (floor 2 6 1 1 ∷ floor 5 3 1 3 ∷ []) false true true 2) (2000 , 4005) (valid (route tt false 0 0 true ((4005 , 5005) ∷ []) (0 ∷ []))) + ⊕ extend (link true 3 0 false (4001 ∷ 2003 ∷ []) (floor 2 6 1 1 ∷ floor 5 3 1 3 ∷ []) false true true 2) (2000 , 4003) (valid (route tt false 0 0 true ((4003 , 5003) ∷ []) (0 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 3 255 false ([]) (floor 0 1 1 2 ∷ floor 4 4 2 1 ∷ floor 5 2 1 2 ∷ []) false true true 3) (1000 , 1003) (valid (route false 128 0 true ((1003 , 1002) ∷ (1002 , 2005) ∷ (2005 , 2006) ∷ []) (1 ∷ 1 ∷ 2 ∷ []))) - ⊕ extend (link true 2 0 true ([]) (floor 0 1 1 2 ∷ floor 4 4 2 1 ∷ floor 5 2 1 2 ∷ []) true false true 3) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 0 2 true ((1000 , 1006) ∷ []) (3 ∷ [])) +_ : extend (link true 3 128 true (2001 ∷ []) (floor 4 6 1 1 ∷ []) false true false 1) (2000 , 2001) (valid (route tt true 255 9 false ((2001 , 4006) ∷ (4006 , 4002) ∷ (4002 , 5002) ∷ []) (3 ∷ 2 ∷ 0 ∷ []))) + ⊕ extend (link true 3 128 true (2001 ∷ []) (floor 4 6 1 1 ∷ []) true true false 1) (2000 , 2006) (valid (route tt true 255 9 false ((2006 , 4006) ∷ (4006 , 4002) ∷ (4002 , 5002) ∷ []) (3 ∷ 2 ∷ 0 ∷ []))) + ≡ valid (route tt true 255 12 false ((2000 , 2001) ∷ (2001 , 4006) ∷ (4006 , 4002) ∷ (4002 , 5002) ∷ []) (1 ∷ 3 ∷ 2 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 1 128 false (1006 ∷ 2006 ∷ []) ([]) false false true 1) (1000 , 2003) (valid (route false 122 8 false ((2003 , 1004) ∷ []) (2 ∷ []))) - ⊕ extend (link true 4 128 false (1006 ∷ 2006 ∷ []) ([]) false false false 3) (1000 , 1002) (valid (route true 128 0 false ((1002 , 1004) ∷ (1004 , 2006) ∷ (2006 , 2005) ∷ (2005 , 1001) ∷ []) (3 ∷ 2 ∷ 2 ∷ 2 ∷ []))) - ≡ valid (route false 128 9 false ((1000 , 2003) ∷ (2003 , 1004) ∷ []) (1 ∷ 2 ∷ [])) +_ : extend (link true 4 255 false (4001 ∷ []) ([]) false false true 3) (2000 , 4004) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 4 255 false (4001 ∷ []) ([]) false false true 3) (2000 , 4001) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 255 4 false ((2000 , 4004) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 3 255 false (1006 ∷ []) ([]) false true false 1) (1000 , 1004) (valid (route true 128 3 true ((1004 , 1005) ∷ []) (3 ∷ []))) - ⊕ extend (link true 2 0 false (1006 ∷ []) ([]) true false false 3) (1000 , 1002) (valid (route false 127 1 true ((1002 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2002) ∷ []) (1 ∷ 3 ∷ 1 ∷ []))) - ≡ valid (route false 127 3 true ((1000 , 1002) ∷ (1002 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2002) ∷ []) (3 ∷ 1 ∷ 3 ∷ 1 ∷ [])) +_ : extend (link true 2 122 false (4006 ∷ []) (floor 2 2 2 2 ∷ floor 5 1 2 0 ∷ []) false false false 1) (2000 , 4001) (valid (route tt false 128 11 true ((4001 , 4005) ∷ (4005 , 2003) ∷ []) (2 ∷ 1 ∷ []))) + ⊕ extend (link true 2 122 false (4006 ∷ []) (floor 2 2 2 2 ∷ floor 5 1 2 0 ∷ []) false false false 1) (2000 , 4002) (valid (route tt false 128 11 true ((4002 , 4005) ∷ (4005 , 2003) ∷ []) (2 ∷ 1 ∷ []))) + ≡ valid (route tt false 128 13 true ((2000 , 4001) ∷ (4001 , 4005) ∷ (4005 , 2003) ∷ []) (1 ∷ 2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 127 false (2003 ∷ []) ([]) false true true 3) (1000 , 2006) (valid (route false 128 2 false ((2006 , 2005) ∷ (2005 , 1000) ∷ (1000 , 1003) ∷ (1003 , 1002) ∷ []) (1 ∷ 3 ∷ 3 ∷ 3 ∷ []))) - ⊕ extend (link true 4 127 false (2003 ∷ []) ([]) false true true 3) (1000 , 2002) (valid (route false 128 2 false ((2002 , 2005) ∷ (2005 , 1000) ∷ (1000 , 1003) ∷ (1003 , 1002) ∷ []) (1 ∷ 3 ∷ 3 ∷ 3 ∷ []))) - ≡ invalid +_ : extend (link true 2 0 false ([]) (floor 5 3 2 1 ∷ floor 5 5 2 2 ∷ floor 6 5 2 1 ∷ []) false false true 1) (2000 , 2001) (valid (route tt false 0 0 true ((2001 , 3001) ∷ []) (0 ∷ []))) + ⊕ extend (link true 2 0 false ([]) (floor 5 3 2 1 ∷ floor 5 5 2 2 ∷ floor 6 5 2 1 ∷ []) false false true 1) (2000 , 4005) (valid (route tt false 0 0 true ((4005 , 5005) ∷ []) (0 ∷ []))) + ≡ valid (route tt false 0 2 true ((2000 , 2001) ∷ (2001 , 3001) ∷ []) (1 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 1 255 false ([]) (floor 3 1 1 3 ∷ []) false false true 2) (1000 , 1005) (valid (route false 255 10 false ((1005 , 2005) ∷ (2005 , 1002) ∷ []) (1 ∷ 3 ∷ []))) - ⊕ extend (link true 3 0 true ([]) (floor 3 1 1 3 ∷ []) true true true 2) (1000 , 2004) (valid (route false 122 11 false ((2004 , 1004) ∷ (1004 , 2006) ∷ []) (2 ∷ 3 ∷ []))) - ≡ valid (route false 255 11 false ((1000 , 1005) ∷ (1005 , 2005) ∷ (2005 , 1002) ∷ []) (2 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 1 127 false (2002 ∷ []) ([]) true false true 1) (2000 , 4006) (valid (route tt false 0 0 true ((4006 , 5006) ∷ []) (0 ∷ []))) + ⊕ extend (link true 1 128 false (2002 ∷ []) ([]) false false true 1) (2000 , 2004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 127 1 true ((2000 , 4006) ∷ (4006 , 5006) ∷ []) (1 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 3 127 true (2002 ∷ []) (floor 6 5 1 1 ∷ []) false false false 2) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 3 127 true (2002 ∷ []) (floor 6 5 1 1 ∷ []) false false false 2) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) - ≡ invalid +_ : extend (link true 2 122 false (2006 ∷ []) (floor 5 6 1 3 ∷ floor 6 2 2 3 ∷ floor 6 5 1 1 ∷ []) false false false 1) (2000 , 4005) (valid (route tt false 128 6 true ((4005 , 4001) ∷ (4001 , 2004) ∷ (2004 , 4002) ∷ []) (1 ∷ 1 ∷ 1 ∷ []))) + ⊕ extend (link true 2 122 false (2006 ∷ []) (floor 5 6 1 3 ∷ floor 6 2 2 3 ∷ floor 6 5 1 1 ∷ []) false false false 1) (2000 , 4003) (valid (route tt false 128 6 true ((4003 , 2181) ∷ (2181 , 4001) ∷ (4001 , 2004) ∷ (2004 , 4002) ∷ []) (1 ∷ 1 ∷ 1 ∷ 1 ∷ []))) + ≡ valid (route tt false 128 8 true ((2000 , 4005) ∷ (4005 , 4001) ∷ (4001 , 2004) ∷ (2004 , 4002) ∷ []) (1 ∷ 1 ∷ 1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 255 false ([]) ([]) true true true 1) (1000 , 2004) (valid (route false 0 8 false ((2004 , 2002) ∷ []) (2 ∷ []))) - ⊕ extend (link true 4 255 false ([]) ([]) true true true 1) (1000 , 1002) (valid (route false 0 8 false ((1002 , 2002) ∷ []) (2 ∷ []))) - ≡ valid (route false 255 12 true ((1000 , 1002) ∷ (1002 , 2002) ∷ []) (1 ∷ 2 ∷ [])) +_ : extend (link true 3 128 false (2001 ∷ []) ([]) false false false 1) (2000 , 2006) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 3 255 false (2001 ∷ []) ([]) false false true 1) (2000 , 2002) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 255 3 false ((2000 , 2002) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 1 127 true ([]) (floor 0 3 1 1 ∷ floor 1 2 2 0 ∷ []) true false true 2) (1000 , 2006) (valid (route false 127 0 false ((2006 , 2003) ∷ (2003 , 1000) ∷ (1000 , 1005) ∷ (1005 , 2004) ∷ []) (1 ∷ 1 ∷ 3 ∷ 3 ∷ []))) - ⊕ extend (link true 2 122 false ([]) (floor 0 3 1 1 ∷ floor 1 2 2 0 ∷ []) true false true 2) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 122 2 true ((1000 , 1002) ∷ []) (2 ∷ [])) +_ : extend (link true 4 255 false (2003 ∷ 2006 ∷ []) (floor 2 5 1 1 ∷ floor 6 0 2 1 ∷ floor 6 1 2 3 ∷ []) true true true 2) (2000 , 4005) (valid (route tt true 255 2 false ((4005 , 2002) ∷ []) (3 ∷ []))) + ⊕ extend (link true 4 255 false (2003 ∷ 2006 ∷ []) (floor 2 5 1 1 ∷ floor 6 0 2 1 ∷ floor 6 1 2 3 ∷ []) true true true 2) (2000 , 2005) (valid (route tt true 255 2 false ((2005 , 2002) ∷ []) (3 ∷ []))) + ≡ valid (route tt true 255 6 true ((2000 , 2005) ∷ (2005 , 2002) ∷ []) (2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 128 true (2004 ∷ []) (floor 2 3 2 3 ∷ []) false false true 3) (1000 , 1003) (valid (route false 128 2 true ((1003 , 1000) ∷ []) (2 ∷ []))) - ⊕ extend (link true 3 128 true (2004 ∷ []) (floor 2 3 2 3 ∷ []) false false true 3) (1000 , 1001) (valid (route false 128 2 true ((1001 , 1000) ∷ []) (2 ∷ []))) - ≡ invalid +_ : extend (link true 1 0 false (4002 ∷ 4003 ∷ []) (floor 2 2 1 1 ∷ floor 6 6 1 1 ∷ []) false false true 3) (2000 , 4003) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 1 0 false (4002 ∷ 4003 ∷ []) (floor 2 2 1 1 ∷ floor 6 6 1 1 ∷ []) true false true 3) (2000 , 2005) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 1 true ((2000 , 2005) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 2 0 false (1004 ∷ 2005 ∷ []) (floor 0 0 2 2 ∷ floor 3 0 1 1 ∷ []) false false true 2) (1000 , 2004) (valid (route false 122 10 true ((2004 , 1003) ∷ []) (3 ∷ []))) - ⊕ extend (link true 4 128 false (1004 ∷ 2005 ∷ []) (floor 0 0 2 2 ∷ floor 3 0 1 1 ∷ []) false false false 2) (1000 , 1005) (valid (route true 128 2 true ((1005 , 2006) ∷ []) (2 ∷ []))) - ≡ valid (route false 122 12 true ((1000 , 2004) ∷ (2004 , 1003) ∷ []) (2 ∷ 3 ∷ [])) +_ : extend (link true 1 255 false (2001 ∷ []) (floor 2 0 1 2 ∷ []) false false false 3) (2000 , 2002) (valid (route tt true 0 0 false ((2002 , 4005) ∷ (4005 , 2003) ∷ (2003 , 2001) ∷ []) (1 ∷ 3 ∷ 3 ∷ []))) + ⊕ extend (link true 2 0 false (2001 ∷ []) (floor 2 0 1 2 ∷ []) false false true 1) (2000 , 2006) (valid (route tt false 128 8 false ((2006 , 2005) ∷ (2005 , 4002) ∷ (4002 , 4001) ∷ (4001 , 5001) ∷ []) (1 ∷ 2 ∷ 3 ∷ 0 ∷ []))) + ≡ valid (route tt false 128 10 false ((2000 , 2006) ∷ (2006 , 2005) ∷ (2005 , 4002) ∷ (4002 , 4001) ∷ (4001 , 5001) ∷ []) (1 ∷ 1 ∷ 2 ∷ 3 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 2 127 true ([]) (floor 2 4 2 0 ∷ floor 3 3 2 2 ∷ []) false false true 2) (1000 , 1002) (valid (route true 128 7 true ((1002 , 1006) ∷ (1006 , 2004) ∷ (2004 , 2002) ∷ []) (1 ∷ 1 ∷ 2 ∷ []))) - ⊕ extend (link true 2 127 true ([]) (floor 2 4 2 0 ∷ floor 3 3 2 2 ∷ []) false false true 2) (1000 , 2006) (valid (route true 128 7 true ((2006 , 1006) ∷ (1006 , 2004) ∷ (2004 , 2002) ∷ []) (1 ∷ 1 ∷ 2 ∷ []))) - ≡ valid (route true 128 9 true ((1000 , 1002) ∷ (1002 , 1006) ∷ (1006 , 2004) ∷ (2004 , 2002) ∷ []) (2 ∷ 1 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 4 128 false ([]) ([]) true false true 1) (2000 , 4003) (valid (route tt false 122 6 true ((4003 , 4005) ∷ (4005 , 2001) ∷ (2001 , 4006) ∷ []) (2 ∷ 3 ∷ 3 ∷ []))) + ⊕ extend (link true 4 128 false ([]) ([]) false false true 3) (2000 , 4004) (valid (route tt false 0 8 false ((4004 , 2001) ∷ (2001 , 2002) ∷ []) (1 ∷ 3 ∷ []))) + ≡ valid (route tt false 128 10 true ((2000 , 4003) ∷ (4003 , 4005) ∷ (4005 , 2001) ∷ (2001 , 4006) ∷ []) (1 ∷ 2 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 122 false ([]) (floor 5 4 2 3 ∷ []) false true true 2) (1000 , 2003) (valid (route true 128 6 true ((2003 , 1001) ∷ (1001 , 1003) ∷ (1003 , 2006) ∷ (2006 , 2002) ∷ []) (3 ∷ 2 ∷ 2 ∷ 1 ∷ []))) - ⊕ extend (link true 1 122 false ([]) (floor 5 4 2 3 ∷ []) false true true 2) (1000 , 2002) (valid (route true 128 6 true ((2002 , 1001) ∷ (1001 , 1003) ∷ (1003 , 2006) ∷ (2006 , 2002) ∷ []) (3 ∷ 2 ∷ 2 ∷ 1 ∷ []))) - ≡ invalid +_ : extend (link true 2 0 false (2002 ∷ 4006 ∷ []) (floor 3 5 2 2 ∷ floor 6 6 2 2 ∷ []) false false true 3) (2000 , 2002) (valid (route tt false 0 0 true ((2002 , 3002) ∷ []) (0 ∷ []))) + ⊕ extend (link true 2 0 false (2002 ∷ 4006 ∷ []) (floor 3 5 2 2 ∷ floor 6 6 2 2 ∷ []) true false true 3) (2000 , 4003) (valid (route tt false 0 0 true ((4003 , 5003) ∷ []) (0 ∷ []))) + ≡ valid (route tt false 0 2 true ((2000 , 4003) ∷ (4003 , 5003) ∷ []) (3 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 4 127 false (1006 ∷ []) ([]) false true false 1) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 4 127 false (1006 ∷ []) ([]) false true false 1) (1000 , 1001) (valid (route false 0 0 false ([]) ([]))) - ≡ invalid +_ : extend (link true 2 255 true ([]) (floor 3 5 2 1 ∷ floor 4 0 2 1 ∷ []) false true true 1) (2000 , 4005) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 2 255 true ([]) (floor 3 5 2 1 ∷ floor 4 0 2 1 ∷ []) true true true 1) (2000 , 2003) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 255 2 false ((2000 , 4005) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 128 false (2006 ∷ []) (floor 0 6 1 0 ∷ floor 2 4 2 2 ∷ floor 3 2 2 0 ∷ []) true true false 1) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 1 122 true (2006 ∷ []) (floor 0 6 1 0 ∷ floor 2 4 2 2 ∷ floor 3 2 2 0 ∷ []) false true true 1) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 122 1 false ((1000 , 2003) ∷ []) (1 ∷ [])) +_ : extend (link true 2 0 false (2002 ∷ 4002 ∷ []) (floor 3 3 2 3 ∷ []) true false true 3) (2000 , 4003) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 2 0 false (2002 ∷ 4002 ∷ []) (floor 3 3 2 3 ∷ []) true false true 3) (2000 , 2004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 2 true ((2000 , 4003) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 2 122 false ([]) (floor 3 2 2 0 ∷ []) false false true 3) (1000 , 1005) (valid (route true 0 7 false ((1005 , 2006) ∷ []) (2 ∷ []))) - ⊕ extend (link true 3 0 false ([]) (floor 3 2 2 0 ∷ []) false false false 1) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 122 9 false ((1000 , 1005) ∷ (1005 , 2006) ∷ []) (3 ∷ 2 ∷ [])) +_ : extend (link true 1 122 false ([]) (floor 1 4 1 0 ∷ floor 4 0 1 2 ∷ []) false false true 2) (2000 , 2001) (valid (route tt false 122 1 true ((2001 , 4002) ∷ (4002 , 2004) ∷ []) (3 ∷ 3 ∷ []))) + ⊕ extend (link true 2 128 true ([]) (floor 1 4 1 0 ∷ floor 4 0 1 2 ∷ []) false false true 1) (2000 , 4006) (valid (route tt false 128 5 false ((4006 , 2005) ∷ (2005 , 2004) ∷ []) (1 ∷ 2 ∷ []))) + ≡ valid (route tt false 122 2 true ((2000 , 2001) ∷ (2001 , 4002) ∷ (4002 , 2004) ∷ []) (2 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 255 false (1005 ∷ 2002 ∷ []) ([]) false false false 2) (1000 , 2003) (valid (route false 127 3 false ((2003 , 2004) ∷ (2004 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2001) ∷ []) (3 ∷ 3 ∷ 1 ∷ 1 ∷ []))) - ⊕ extend (link true 3 122 false (1005 ∷ 2002 ∷ []) ([]) false true true 3) (1000 , 1006) (valid (route true 122 1 false ((1006 , 2005) ∷ (2005 , 2001) ∷ []) (1 ∷ 3 ∷ []))) - ≡ valid (route true 122 4 false ((1000 , 1006) ∷ (1006 , 2005) ∷ (2005 , 2001) ∷ []) (3 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 2 255 true (2002 ∷ []) (floor 1 3 2 0 ∷ floor 4 1 1 2 ∷ floor 6 4 1 0 ∷ []) true true true 2) (2000 , 4006) (valid (route tt false 127 11 false ((4006 , 2002) ∷ (2002 , 4001) ∷ (4001 , 5001) ∷ []) (1 ∷ 2 ∷ 0 ∷ []))) + ⊕ extend (link true 4 122 false (2002 ∷ []) (floor 1 3 2 0 ∷ floor 4 1 1 2 ∷ floor 6 4 1 0 ∷ []) false false true 2) (2000 , 2002) (valid (route tt false 255 9 false ((2002 , 4006) ∷ (4006 , 4003) ∷ (4003 , 2005) ∷ []) (3 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route tt true 255 13 false ((2000 , 2002) ∷ (2002 , 4006) ∷ (4006 , 4003) ∷ (4003 , 2005) ∷ []) (2 ∷ 3 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 2 128 false (1005 ∷ 2006 ∷ []) (floor 0 6 1 2 ∷ floor 6 4 1 0 ∷ []) false false false 3) (1000 , 2003) (valid (route false 127 8 true ((2003 , 2001) ∷ []) (2 ∷ []))) - ⊕ extend (link true 2 128 false (1005 ∷ 2006 ∷ []) (floor 0 6 1 2 ∷ floor 6 4 1 0 ∷ []) false false false 3) (1000 , 1004) (valid (route false 127 8 true ((1004 , 2001) ∷ []) (2 ∷ []))) - ≡ valid (route false 128 10 true ((1000 , 2003) ∷ (2003 , 2001) ∷ []) (3 ∷ 2 ∷ [])) +_ : extend (link true 1 122 false ([]) (floor 1 1 1 2 ∷ floor 2 2 1 2 ∷ []) false false false 3) (2000 , 4003) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 1 122 false ([]) (floor 1 1 1 2 ∷ floor 2 2 1 2 ∷ []) false false false 3) (2000 , 4004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ invalid _ = refl -_ : extend (link true 3 127 true ([]) (floor 0 4 1 0 ∷ floor 2 1 1 0 ∷ floor 4 4 2 1 ∷ []) true true false 3) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 3 127 false ([]) (floor 0 4 1 0 ∷ floor 2 1 1 0 ∷ floor 4 4 2 1 ∷ []) false true true 3) (1000 , 1001) (valid (route false 128 9 true ((1001 , 1000) ∷ (1000 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1002) ∷ []) (1 ∷ 1 ∷ 1 ∷ 2 ∷ []))) +_ : extend (link true 2 122 false (2004 ∷ 2005 ∷ []) (floor 4 3 1 0 ∷ floor 5 4 2 0 ∷ []) true true false 1) (2000 , 2004) (valid (route tt false 0 0 true ((2004 , 3004) ∷ []) (0 ∷ []))) + ⊕ extend (link true 2 122 false (2004 ∷ 2005 ∷ []) (floor 4 3 1 0 ∷ floor 5 4 2 0 ∷ []) true true false 1) (2000 , 4001) (valid (route tt false 0 0 true ((4001 , 5001) ∷ []) (0 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 0 false (1001 ∷ 1003 ∷ []) (floor 0 0 1 1 ∷ floor 2 2 2 0 ∷ []) false false true 2) (1000 , 1003) (valid (route false 127 5 false ((1003 , 1002) ∷ []) (2 ∷ []))) - ⊕ extend (link true 1 0 false (1001 ∷ 1003 ∷ []) (floor 0 0 1 1 ∷ floor 2 2 2 0 ∷ []) false false true 2) (1000 , 1004) (valid (route false 127 5 false ((1004 , 1002) ∷ []) (2 ∷ []))) - ≡ valid (route false 127 6 false ((1000 , 1004) ∷ (1004 , 1002) ∷ []) (2 ∷ 2 ∷ [])) +_ : extend (link true 2 0 false ([]) (floor 1 6 1 1 ∷ floor 2 1 1 2 ∷ []) false true true 1) (2000 , 2004) (valid (route tt true 128 11 false ((2004 , 2002) ∷ (2002 , 4005) ∷ (4005 , 4006) ∷ (4006 , 4001) ∷ []) (1 ∷ 3 ∷ 1 ∷ 2 ∷ []))) + ⊕ extend (link true 2 0 false ([]) (floor 1 6 1 1 ∷ floor 2 1 1 2 ∷ []) false true true 1) (2000 , 2001) (valid (route tt true 128 11 false ((2001 , 2002) ∷ (2002 , 4005) ∷ (4005 , 4006) ∷ (4006 , 4001) ∷ []) (1 ∷ 3 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route tt true 128 13 false ((2000 , 2001) ∷ (2001 , 2002) ∷ (2002 , 4005) ∷ (4005 , 4006) ∷ (4006 , 4001) ∷ []) (1 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 127 false ([]) ([]) true false false 2) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 1 127 false ([]) ([]) false false true 2) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 127 1 false ((1000 , 1002) ∷ []) (2 ∷ [])) +_ : extend (link true 2 0 false (4006 ∷ []) ([]) false false true 3) (2000 , 2005) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 2 0 false (4006 ∷ []) ([]) true false true 3) (2000 , 4005) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 2 false ((2000 , 2005) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 4 128 false ([]) (floor 1 2 2 1 ∷ floor 1 6 1 3 ∷ floor 5 3 1 1 ∷ []) false false true 2) (1000 , 1003) (valid (route true 0 9 true ((1003 , 2004) ∷ []) (1 ∷ []))) - ⊕ extend (link true 4 128 false ([]) (floor 1 2 2 1 ∷ floor 1 6 1 3 ∷ floor 5 3 1 1 ∷ []) false false true 2) (1000 , 2001) (valid (route true 0 9 true ((2001 , 2004) ∷ []) (1 ∷ []))) - ≡ valid (route true 128 13 true ((1000 , 2001) ∷ (2001 , 2004) ∷ []) (2 ∷ 1 ∷ [])) +_ : extend (link true 2 122 true (2005 ∷ []) (floor 2 0 1 0 ∷ floor 4 1 2 2 ∷ floor 4 6 1 0 ∷ []) true false true 3) (2000 , 4003) (valid (route tt false 122 9 false ((4003 , 4002) ∷ []) (3 ∷ []))) + ⊕ extend (link true 1 127 false (2005 ∷ []) (floor 2 0 1 0 ∷ floor 4 1 2 2 ∷ floor 4 6 1 0 ∷ []) true false false 2) (2000 , 2004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 122 11 true ((2000 , 4003) ∷ (4003 , 4002) ∷ []) (3 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 4 128 false ([]) ([]) false false false 1) (2000 , 4001) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 4 128 false ([]) ([]) true true true 2) (2000 , 2003) (valid (route tt true 127 4 true ((2003 , 2005) ∷ []) (1 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 4 122 false (2003 ∷ []) (floor 5 6 1 2 ∷ floor 6 6 2 1 ∷ []) true true true 3) (1000 , 2005) (valid (route false 122 3 false ((2005 , 1001) ∷ []) (2 ∷ []))) - ⊕ extend (link true 4 122 false (2003 ∷ []) (floor 5 6 1 2 ∷ floor 6 6 2 1 ∷ []) true true true 3) (1000 , 1006) (valid (route false 122 3 false ((1006 , 1001) ∷ []) (2 ∷ []))) - ≡ valid (route false 122 7 true ((1000 , 2005) ∷ (2005 , 1001) ∷ []) (3 ∷ 2 ∷ [])) +_ : extend (link true 4 0 false (4001 ∷ []) (floor 1 3 1 3 ∷ floor 5 4 1 1 ∷ floor 5 6 2 0 ∷ []) false false true 2) (2000 , 2006) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 4 0 false (4001 ∷ []) (floor 1 3 1 3 ∷ floor 5 4 1 1 ∷ floor 5 6 2 0 ∷ []) false false true 2) (2000 , 4004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 4 false ((2000 , 4004) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 3 122 false (2001 ∷ []) (floor 3 4 2 0 ∷ floor 5 0 2 1 ∷ []) false false true 3) (1000 , 2003) (valid (route false 0 2 true ((2003 , 1000) ∷ (1000 , 1003) ∷ (1003 , 1001) ∷ (1001 , 1004) ∷ []) (3 ∷ 2 ∷ 2 ∷ 2 ∷ []))) - ⊕ extend (link true 4 255 true (2001 ∷ []) (floor 3 4 2 0 ∷ floor 5 0 2 1 ∷ []) true false true 1) (1000 , 2001) (valid (route false 128 3 false ((2001 , 1001) ∷ (1001 , 1005) ∷ []) (2 ∷ 2 ∷ []))) - ≡ valid (route true 255 7 true ((1000 , 2001) ∷ (2001 , 1001) ∷ (1001 , 1005) ∷ []) (1 ∷ 2 ∷ 2 ∷ [])) +_ : extend (link true 3 128 false (2002 ∷ []) (floor 2 0 2 3 ∷ floor 4 2 1 2 ∷ floor 6 5 1 3 ∷ []) true true true 3) (2000 , 4006) (valid (route tt false 255 6 false ((4006 , 2004) ∷ (2004 , 3004) ∷ []) (3 ∷ 0 ∷ []))) + ⊕ extend (link true 3 128 false (2002 ∷ []) (floor 2 0 2 3 ∷ floor 4 2 1 2 ∷ floor 6 5 1 3 ∷ []) true true true 3) (2000 , 2005) (valid (route tt false 255 6 false ((2005 , 2157) ∷ (2157 , 2004) ∷ (2004 , 3004) ∷ []) (3 ∷ 1 ∷ 0 ∷ []))) + ≡ valid (route tt false 255 9 true ((2000 , 4006) ∷ (4006 , 2004) ∷ (2004 , 3004) ∷ []) (3 ∷ 3 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 3 122 true ([]) (floor 1 4 1 0 ∷ floor 2 3 2 3 ∷ floor 4 5 1 3 ∷ []) true false true 1) (1000 , 1005) (valid (route false 127 2 false ((1005 , 1000) ∷ []) (1 ∷ []))) - ⊕ extend (link true 3 122 true ([]) (floor 1 4 1 0 ∷ floor 2 3 2 3 ∷ floor 4 5 1 3 ∷ []) true false true 1) (1000 , 1004) (valid (route false 127 2 false ((1004 , 1000) ∷ []) (1 ∷ []))) +_ : extend (link true 4 122 false ([]) (floor 3 2 2 3 ∷ []) false false false 3) (2000 , 4006) (valid (route tt true 122 0 false ((4006 , 4003) ∷ []) (2 ∷ []))) + ⊕ extend (link true 4 122 false ([]) (floor 3 2 2 3 ∷ []) false false false 3) (2000 , 4005) (valid (route tt true 122 0 false ((4005 , 4003) ∷ []) (2 ∷ []))) + ≡ valid (route tt true 122 4 false ((2000 , 4005) ∷ (4005 , 4003) ∷ []) (3 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 4 122 false ([]) (floor 4 3 1 2 ∷ floor 5 3 1 2 ∷ []) false true true 3) (2000 , 4005) (valid (route tt false 128 7 true ((4005 , 2004) ∷ (2004 , 2001) ∷ (2001 , 2003) ∷ []) (3 ∷ 1 ∷ 1 ∷ []))) + ⊕ extend (link true 4 122 false ([]) (floor 4 3 1 2 ∷ floor 5 3 1 2 ∷ []) false true true 3) (2000 , 2003) (valid (route tt false 128 7 true ((2003 , 2113) ∷ (2113 , 2004) ∷ (2004 , 2001) ∷ (2001 , 2003) ∷ []) (3 ∷ 1 ∷ 1 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 255 true (2006 ∷ []) (floor 1 3 2 3 ∷ floor 3 1 1 3 ∷ floor 6 5 2 3 ∷ []) false true false 3) (1000 , 2004) (valid (route false 0 6 true ((2004 , 2002) ∷ (2002 , 2005) ∷ []) (1 ∷ 3 ∷ []))) - ⊕ extend (link true 2 0 false (2006 ∷ []) (floor 1 3 2 3 ∷ floor 3 1 1 3 ∷ floor 6 5 2 3 ∷ []) false true true 1) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 0 2 false ((1000 , 1003) ∷ []) (1 ∷ [])) +_ : extend (link true 3 122 false ([]) ([]) false true true 2) (2000 , 2005) (valid (route tt false 255 4 true ((2005 , 2003) ∷ (2003 , 4006) ∷ (4006 , 2002) ∷ (2002 , 4000) ∷ []) (2 ∷ 2 ∷ 1 ∷ 2 ∷ []))) + ⊕ extend (link true 4 255 false ([]) ([]) false false true 1) (2000 , 2001) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 255 4 false ((2000 , 2001) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 128 true (1005 ∷ []) (floor 0 1 2 3 ∷ []) false false false 2) (1000 , 2006) (valid (route false 0 8 true ((2006 , 1005) ∷ (1005 , 2001) ∷ (2001 , 2004) ∷ (2004 , 2003) ∷ []) (2 ∷ 3 ∷ 2 ∷ 3 ∷ []))) - ⊕ extend (link true 3 127 true (1005 ∷ []) (floor 0 1 2 3 ∷ []) false true true 1) (1000 , 2004) (valid (route false 255 4 false ((2004 , 2003) ∷ (2003 , 2006) ∷ []) (3 ∷ 1 ∷ []))) - ≡ valid (route true 128 10 true ((1000 , 2006) ∷ (2006 , 1005) ∷ (1005 , 2001) ∷ (2001 , 2004) ∷ (2004 , 2003) ∷ []) (2 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 3 0 true ([]) ([]) false false true 1) (2000 , 4005) (valid (route tt false 255 8 false ((4005 , 4003) ∷ (4003 , 2004) ∷ []) (2 ∷ 2 ∷ []))) + ⊕ extend (link true 3 0 true ([]) ([]) true false true 1) (2000 , 2006) (valid (route tt false 255 8 false ((2006 , 4003) ∷ (4003 , 2004) ∷ []) (2 ∷ 2 ∷ []))) + ≡ valid (route tt true 255 11 false ((2000 , 4005) ∷ (4005 , 4003) ∷ (4003 , 2004) ∷ []) (1 ∷ 2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 2 122 true ([]) (floor 2 4 1 2 ∷ floor 3 3 2 2 ∷ floor 4 1 1 3 ∷ []) false false false 2) (1000 , 1006) (valid (route false 122 11 false ((1006 , 1004) ∷ (1004 , 1001) ∷ (1001 , 1002) ∷ []) (3 ∷ 2 ∷ 2 ∷ []))) - ⊕ extend (link true 2 122 true ([]) (floor 2 4 1 2 ∷ floor 3 3 2 2 ∷ floor 4 1 1 3 ∷ []) false false false 2) (1000 , 1003) (valid (route false 122 11 false ((1003 , 1004) ∷ (1004 , 1001) ∷ (1001 , 1002) ∷ []) (3 ∷ 2 ∷ 2 ∷ []))) +_ : extend (link true 1 122 false (2003 ∷ 4006 ∷ []) ([]) false false false 1) (2000 , 4002) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 1 122 false (2003 ∷ 4006 ∷ []) ([]) true false false 1) (2000 , 2003) (valid (route tt false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 3 122 false ([]) (floor 0 5 1 2 ∷ floor 1 0 1 1 ∷ []) false true true 3) (1000 , 1004) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 2 128 false ([]) (floor 0 5 1 2 ∷ floor 1 0 1 1 ∷ []) false true true 1) (1000 , 2003) (valid (route true 255 4 false ((2003 , 1003) ∷ (1003 , 1004) ∷ (1004 , 1005) ∷ []) (2 ∷ 2 ∷ 1 ∷ []))) - ≡ valid (route false 122 3 false ((1000 , 1004) ∷ []) (3 ∷ [])) +_ : extend (link true 2 128 false ([]) ([]) false false false 3) (2000 , 2005) (valid (route tt true 122 2 false ((2005 , 2001) ∷ (2001 , 2000) ∷ (2000 , 2002) ∷ []) (3 ∷ 2 ∷ 3 ∷ []))) + ⊕ extend (link true 2 128 false ([]) ([]) false false false 3) (2000 , 2001) (valid (route tt true 122 2 false ((2001 , 2170) ∷ (2170 , 2001) ∷ (2001 , 2000) ∷ (2000 , 2002) ∷ []) (3 ∷ 1 ∷ 2 ∷ 3 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 3 127 false (2006 ∷ []) (floor 0 3 2 0 ∷ []) false false false 1) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 1 122 false (2006 ∷ []) (floor 0 3 2 0 ∷ []) false false true 2) (1000 , 2003) (valid (route false 122 6 true ((2003 , 1004) ∷ []) (3 ∷ []))) - ≡ valid (route false 122 7 true ((1000 , 2003) ∷ (2003 , 1004) ∷ []) (2 ∷ 3 ∷ [])) +_ : extend (link true 2 127 true ([]) (floor 3 6 2 1 ∷ []) true false false 2) (2000 , 2003) (valid (route tt false 0 0 true ((2003 , 3003) ∷ []) (0 ∷ []))) + ⊕ extend (link true 2 127 true ([]) (floor 3 6 2 1 ∷ []) true false false 2) (2000 , 4001) (valid (route tt false 0 0 true ((4001 , 5001) ∷ []) (0 ∷ []))) + ≡ valid (route tt true 127 2 true ((2000 , 4001) ∷ (4001 , 5001) ∷ []) (2 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 1 127 true (2005 ∷ []) ([]) true false false 1) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 1 127 true (2005 ∷ []) ([]) true false false 1) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) - ≡ invalid +_ : extend (link true 4 0 false (4006 ∷ []) (floor 6 1 1 0 ∷ []) false true true 1) (2000 , 4003) (valid (route tt false 0 2 false ((4003 , 4001) ∷ []) (1 ∷ []))) + ⊕ extend (link true 4 127 false (4006 ∷ []) (floor 6 1 1 0 ∷ []) false false true 2) (2000 , 2001) (valid (route tt false 128 7 false ((2001 , 4000) ∷ (4000 , 4003) ∷ []) (1 ∷ 2 ∷ []))) + ≡ valid (route tt false 0 6 false ((2000 , 4003) ∷ (4003 , 4001) ∷ []) (1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 3 127 false (1003 ∷ []) (floor 1 4 2 2 ∷ floor 5 0 1 1 ∷ floor 5 1 1 3 ∷ []) false false true 1) (1000 , 1001) (valid (route false 122 9 false ((1001 , 2004) ∷ []) (1 ∷ []))) - ⊕ extend (link true 3 127 true (1003 ∷ []) (floor 1 4 2 2 ∷ floor 5 0 1 1 ∷ floor 5 1 1 3 ∷ []) false false false 2) (1000 , 1005) (valid (route false 0 0 false ([]) ([]))) +_ : extend (link true 2 128 false ([]) (floor 1 4 1 3 ∷ []) true true false 2) (2000 , 2002) (valid (route tt true 127 10 false ((2002 , 4001) ∷ (4001 , 4000) ∷ (4000 , 4003) ∷ (4003 , 4004) ∷ []) (3 ∷ 3 ∷ 3 ∷ 3 ∷ []))) + ⊕ extend (link true 4 122 false ([]) (floor 1 4 1 3 ∷ []) false false false 2) (2000 , 2006) (valid (route tt false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 1 128 false (2003 ∷ 2006 ∷ []) ([]) true true false 2) (1000 , 2003) (valid (route false 128 9 false ((2003 , 1006) ∷ (1006 , 1000) ∷ (1000 , 2005) ∷ []) (3 ∷ 1 ∷ 1 ∷ []))) - ⊕ extend (link true 3 0 false (2003 ∷ 2006 ∷ []) ([]) false false true 3) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 0 3 false ((1000 , 1002) ∷ []) (3 ∷ [])) +_ : extend (link true 1 127 false (2006 ∷ []) (floor 2 2 2 2 ∷ floor 4 0 1 3 ∷ floor 5 5 1 1 ∷ []) false true false 1) (2000 , 2002) (valid (route tt false 122 4 true ((2002 , 4000) ∷ []) (2 ∷ []))) + ⊕ extend (link true 1 127 false (2006 ∷ []) (floor 2 2 2 2 ∷ floor 4 0 1 3 ∷ floor 5 5 1 1 ∷ []) false true false 1) (2000 , 2003) (valid (route tt false 122 4 true ((2003 , 4000) ∷ []) (2 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 4 122 false ([]) (floor 2 3 1 2 ∷ []) false false true 3) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 4 122 false ([]) (floor 2 3 1 2 ∷ []) false false true 3) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 122 4 false ((1000 , 1003) ∷ []) (3 ∷ [])) +_ : extend (link true 3 255 false (4002 ∷ []) (floor 1 2 2 2 ∷ floor 6 0 2 1 ∷ floor 6 1 1 3 ∷ []) false true false 1) (2000 , 4001) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 3 0 false (4002 ∷ []) (floor 1 2 2 2 ∷ floor 6 0 2 1 ∷ floor 6 1 1 3 ∷ []) false false true 1) (2000 , 4003) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 3 false ((2000 , 4003) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 3 122 false ([]) (floor 2 6 2 1 ∷ []) true false true 2) (1000 , 1001) (valid (route true 127 4 false ((1001 , 2001) ∷ []) (2 ∷ []))) - ⊕ extend (link true 3 122 false ([]) (floor 2 6 2 1 ∷ []) true false true 2) (1000 , 1002) (valid (route true 127 4 false ((1002 , 2001) ∷ []) (2 ∷ []))) - ≡ valid (route true 127 7 true ((1000 , 1001) ∷ (1001 , 2001) ∷ []) (2 ∷ 2 ∷ [])) +_ : extend (link true 4 255 true (4001 ∷ 4003 ∷ []) (floor 2 1 1 0 ∷ floor 5 1 2 1 ∷ []) false false false 1) (2000 , 2003) (valid (route tt false 0 0 true ((2003 , 3003) ∷ []) (0 ∷ []))) + ⊕ extend (link true 4 255 true (4001 ∷ 4003 ∷ []) (floor 2 1 1 0 ∷ floor 5 1 2 1 ∷ []) false false false 1) (2000 , 2001) (valid (route tt false 0 0 true ((2001 , 3001) ∷ []) (0 ∷ []))) + ≡ valid (route tt true 255 4 true ((2000 , 2001) ∷ (2001 , 3001) ∷ []) (1 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 4 255 false (2006 ∷ []) (floor 1 6 1 1 ∷ []) false false true 1) (1000 , 1004) (valid (route false 0 8 false ((1004 , 2006) ∷ (2006 , 2004) ∷ (2004 , 2001) ∷ []) (3 ∷ 2 ∷ 1 ∷ []))) - ⊕ extend (link true 4 122 false (2006 ∷ []) (floor 1 6 1 1 ∷ []) false false false 3) (1000 , 2002) (valid (route false 255 1 false ((2002 , 1002) ∷ []) (2 ∷ []))) - ≡ valid (route false 255 5 false ((1000 , 2002) ∷ (2002 , 1002) ∷ []) (3 ∷ 2 ∷ [])) +_ : extend (link true 3 0 false (2003 ∷ 4006 ∷ []) (floor 2 1 1 2 ∷ []) true true true 3) (2000 , 2003) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 3 0 false (2003 ∷ 4006 ∷ []) (floor 2 1 1 2 ∷ []) false true true 3) (2000 , 4001) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 3 false ((2000 , 4001) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 3 127 false ([]) (floor 0 6 1 3 ∷ []) false false true 3) (1000 , 2002) (valid (route false 0 9 true ((2002 , 2004) ∷ (2004 , 2006) ∷ []) (1 ∷ 2 ∷ []))) - ⊕ extend (link true 1 0 false ([]) (floor 0 6 1 3 ∷ []) true true true 1) (1000 , 1005) (valid (route false 128 2 false ((1005 , 2001) ∷ (2001 , 1004) ∷ []) (2 ∷ 1 ∷ []))) - ≡ valid (route false 127 12 true ((1000 , 2002) ∷ (2002 , 2004) ∷ (2004 , 2006) ∷ []) (3 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 1 127 false ([]) (floor 1 2 2 0 ∷ []) false false true 3) (2000 , 2001) (valid (route tt false 128 1 true ((2001 , 4006) ∷ []) (1 ∷ []))) + ⊕ extend (link true 1 122 true ([]) (floor 1 2 2 0 ∷ []) true true true 2) (2000 , 4004) (valid (route tt true 128 7 true ((4004 , 4005) ∷ (4005 , 2003) ∷ (2003 , 4001) ∷ (4001 , 2006) ∷ []) (3 ∷ 1 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route tt false 128 2 true ((2000 , 2001) ∷ (2001 , 4006) ∷ []) (3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 3 255 false (1004 ∷ 2004 ∷ []) (floor 1 2 1 2 ∷ floor 1 6 2 0 ∷ []) true false false 1) (1000 , 1004) (valid (route true 0 10 true ((1004 , 2003) ∷ (2003 , 2001) ∷ []) (1 ∷ 2 ∷ []))) - ⊕ extend (link true 3 255 false (1004 ∷ 2004 ∷ []) (floor 1 2 1 2 ∷ floor 1 6 2 0 ∷ []) true false false 1) (1000 , 2001) (valid (route true 0 10 true ((2001 , 2003) ∷ (2003 , 2001) ∷ []) (1 ∷ 2 ∷ []))) - ≡ valid (route true 255 13 true ((1000 , 2001) ∷ (2001 , 2003) ∷ (2003 , 2001) ∷ []) (1 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 3 122 true (2005 ∷ []) (floor 1 0 2 1 ∷ floor 1 2 2 2 ∷ floor 4 4 2 1 ∷ []) true true true 2) (2000 , 4002) (valid (route tt false 0 0 true ((4002 , 5002) ∷ []) (0 ∷ []))) + ⊕ extend (link true 3 122 true (2005 ∷ []) (floor 1 0 2 1 ∷ floor 1 2 2 2 ∷ floor 4 4 2 1 ∷ []) false true true 2) (2000 , 4006) (valid (route tt false 0 0 true ((4006 , 5006) ∷ []) (0 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 3 0 false ([]) ([]) false false true 2) (1000 , 2001) (valid (route false 0 3 true ((2001 , 2002) ∷ []) (3 ∷ []))) - ⊕ extend (link true 3 0 false ([]) ([]) false false true 2) (1000 , 1006) (valid (route false 0 3 true ((1006 , 2002) ∷ []) (3 ∷ []))) - ≡ valid (route false 0 6 true ((1000 , 2001) ∷ (2001 , 2002) ∷ []) (2 ∷ 3 ∷ [])) +_ : extend (link true 1 127 false ([]) ([]) false false true 2) (2000 , 2005) (valid (route tt true 122 3 true ((2005 , 2002) ∷ (2002 , 2006) ∷ (2006 , 2001) ∷ (2001 , 2000) ∷ []) (3 ∷ 1 ∷ 3 ∷ 2 ∷ []))) + ⊕ extend (link true 2 122 true ([]) ([]) false false true 3) (2000 , 4005) (valid (route tt false 128 0 false ((4005 , 4006) ∷ (4006 , 4001) ∷ (4001 , 2003) ∷ []) (2 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route tt true 128 2 false ((2000 , 4005) ∷ (4005 , 4006) ∷ (4006 , 4001) ∷ (4001 , 2003) ∷ []) (3 ∷ 2 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 128 true (1001 ∷ 2006 ∷ []) (floor 3 0 1 2 ∷ floor 5 3 2 0 ∷ floor 6 5 1 1 ∷ []) false false true 1) (1000 , 1003) (valid (route true 255 6 false ((1003 , 1005) ∷ (1005 , 2001) ∷ []) (3 ∷ 3 ∷ []))) - ⊕ extend (link true 3 128 true (1001 ∷ 2006 ∷ []) (floor 3 0 1 2 ∷ floor 5 3 2 0 ∷ floor 6 5 1 1 ∷ []) false false true 1) (1000 , 1004) (valid (route true 255 6 false ((1004 , 1005) ∷ (1005 , 2001) ∷ []) (3 ∷ 3 ∷ []))) - ≡ valid (route true 255 9 false ((1000 , 1003) ∷ (1003 , 1005) ∷ (1005 , 2001) ∷ []) (1 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 1 128 true (2002 ∷ 4005 ∷ []) ([]) false true true 2) (2000 , 2003) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 1 128 true (2002 ∷ 4005 ∷ []) ([]) true true true 2) (2000 , 4002) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 128 1 false ((2000 , 2003) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 3 0 false ([]) (floor 1 5 2 0 ∷ floor 5 3 1 1 ∷ []) true false true 1) (1000 , 2002) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 3 0 false ([]) (floor 1 5 2 0 ∷ floor 5 3 1 1 ∷ []) true false true 1) (1000 , 1001) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 0 3 true ((1000 , 1001) ∷ []) (1 ∷ [])) +_ : extend (link true 2 0 false (4006 ∷ []) (floor 1 3 2 1 ∷ floor 4 2 2 3 ∷ []) false false true 1) (2000 , 2004) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 2 0 false (4006 ∷ []) (floor 1 3 2 1 ∷ floor 4 2 2 3 ∷ []) true false true 1) (2000 , 2003) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 2 false ((2000 , 2004) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 1 122 false (1001 ∷ 2002 ∷ []) (floor 5 2 2 3 ∷ []) false false true 3) (1000 , 2002) (valid (route true 127 1 true ((2002 , 1002) ∷ []) (1 ∷ []))) - ⊕ extend (link true 1 122 false (1001 ∷ 2002 ∷ []) (floor 5 2 2 3 ∷ []) false true true 3) (1000 , 1006) (valid (route false 0 1 false ((1006 , 2003) ∷ (2003 , 2002) ∷ []) (3 ∷ 1 ∷ []))) - ≡ valid (route true 122 2 false ((1000 , 1006) ∷ (1006 , 2003) ∷ (2003 , 2002) ∷ []) (3 ∷ 3 ∷ 1 ∷ [])) +_ : extend (link true 1 255 false (2001 ∷ []) (floor 2 0 2 3 ∷ floor 2 2 2 1 ∷ floor 4 0 1 3 ∷ []) false false true 2) (2000 , 2002) (valid (route tt false 127 4 false ((2002 , 4005) ∷ []) (3 ∷ []))) + ⊕ extend (link true 3 255 false (2001 ∷ []) (floor 2 0 2 3 ∷ floor 2 2 2 1 ∷ floor 4 0 1 3 ∷ []) true false false 2) (2000 , 4006) (valid (route tt false 255 9 false ((4006 , 4000) ∷ (4000 , 2002) ∷ []) (1 ∷ 1 ∷ []))) + ≡ valid (route tt false 255 5 false ((2000 , 2002) ∷ (2002 , 4005) ∷ []) (2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 122 false ([]) ([]) false false true 3) (1000 , 2006) (valid (route false 255 7 true ((2006 , 1005) ∷ []) (3 ∷ []))) - ⊕ extend (link true 4 122 false ([]) ([]) false false true 3) (1000 , 2001) (valid (route false 255 7 true ((2001 , 1005) ∷ []) (3 ∷ []))) - ≡ valid (route false 255 11 true ((1000 , 2001) ∷ (2001 , 1005) ∷ []) (3 ∷ 3 ∷ [])) +_ : extend (link true 3 128 false (2004 ∷ 4005 ∷ []) (floor 1 1 1 2 ∷ floor 3 5 2 1 ∷ floor 5 0 2 1 ∷ []) true true true 2) (2000 , 4003) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 3 128 false (2004 ∷ 4005 ∷ []) (floor 1 1 1 2 ∷ floor 3 5 2 1 ∷ floor 5 0 2 1 ∷ []) true true true 2) (2000 , 2003) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 128 3 true ((2000 , 2003) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 1 122 true (2006 ∷ []) (floor 3 6 2 3 ∷ floor 4 6 1 0 ∷ floor 5 5 1 1 ∷ []) true false false 3) (1000 , 2005) (valid (route true 122 10 true ((2005 , 2002) ∷ (2002 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1005) ∷ []) (1 ∷ 3 ∷ 3 ∷ 2 ∷ []))) - ⊕ extend (link true 1 122 true (2006 ∷ []) (floor 3 6 2 3 ∷ floor 4 6 1 0 ∷ floor 5 5 1 1 ∷ []) true false false 3) (1000 , 1002) (valid (route true 122 10 true ((1002 , 2002) ∷ (2002 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1005) ∷ []) (1 ∷ 3 ∷ 3 ∷ 2 ∷ []))) - ≡ valid (route true 122 11 true ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1005) ∷ []) (3 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ [])) +_ : extend (link true 1 122 false (4006 ∷ []) (floor 6 0 1 3 ∷ floor 6 2 1 1 ∷ []) true true true 1) (2000 , 4003) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 1 122 false (4006 ∷ []) (floor 6 0 1 3 ∷ floor 6 2 1 1 ∷ []) false true true 1) (2000 , 4002) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 122 1 false ((2000 , 4002) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 3 255 true (1004 ∷ []) ([]) true false false 1) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 3 255 true (1004 ∷ []) ([]) false false true 3) (1000 , 2001) (valid (route false 127 11 true ((2001 , 2006) ∷ (2006 , 1000) ∷ (1000 , 1001) ∷ (1001 , 1005) ∷ []) (2 ∷ 2 ∷ 1 ∷ 3 ∷ []))) - ≡ invalid +_ : extend (link true 2 127 false (2001 ∷ 2006 ∷ []) (floor 2 1 2 1 ∷ floor 4 6 2 2 ∷ floor 5 0 2 0 ∷ []) false true true 2) (2000 , 4003) (valid (route tt false 127 9 false ((4003 , 2005) ∷ (2005 , 4001) ∷ (4001 , 4002) ∷ (4002 , 2000) ∷ []) (3 ∷ 3 ∷ 3 ∷ 1 ∷ []))) + ⊕ extend (link true 4 255 false (2001 ∷ 2006 ∷ []) (floor 2 1 2 1 ∷ floor 4 6 2 2 ∷ floor 5 0 2 0 ∷ []) false false true 3) (2000 , 4004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 255 4 false ((2000 , 4004) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 2 255 false (1003 ∷ []) (floor 0 6 1 3 ∷ []) true true true 3) (1000 , 1002) (valid (route true 128 2 false ((1002 , 1001) ∷ []) (1 ∷ []))) - ⊕ extend (link true 2 255 false (1003 ∷ []) (floor 0 6 1 3 ∷ []) true true true 3) (1000 , 2001) (valid (route true 128 2 false ((2001 , 1001) ∷ []) (1 ∷ []))) - ≡ valid (route true 255 4 true ((1000 , 2001) ∷ (2001 , 1001) ∷ []) (3 ∷ 1 ∷ [])) +_ : extend (link true 4 0 true (4001 ∷ 4005 ∷ []) (floor 3 3 2 0 ∷ floor 5 1 1 1 ∷ []) false false false 1) (2000 , 2002) (valid (route tt false 122 5 false ((2002 , 4005) ∷ (4005 , 2006) ∷ (2006 , 4004) ∷ []) (3 ∷ 3 ∷ 2 ∷ []))) + ⊕ extend (link true 1 255 true (4001 ∷ 4005 ∷ []) (floor 3 3 2 0 ∷ floor 5 1 1 1 ∷ []) false false true 1) (2000 , 2003) (valid (route tt false 122 2 false ((2003 , 2006) ∷ []) (1 ∷ []))) + ≡ valid (route tt true 122 9 false ((2000 , 2002) ∷ (2002 , 4005) ∷ (4005 , 2006) ∷ (2006 , 4004) ∷ []) (1 ∷ 3 ∷ 3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 2 0 true (1005 ∷ 2005 ∷ []) (floor 6 3 2 1 ∷ []) false true true 3) (1000 , 2004) (valid (route false 128 6 true ((2004 , 2002) ∷ (2002 , 2003) ∷ []) (1 ∷ 3 ∷ []))) - ⊕ extend (link true 1 255 false (1005 ∷ 2005 ∷ []) (floor 6 3 2 1 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 255 1 false ((1000 , 1002) ∷ []) (2 ∷ [])) +_ : extend (link true 4 0 false (2006 ∷ []) (floor 1 6 2 3 ∷ floor 2 3 1 2 ∷ floor 3 4 1 1 ∷ []) false false true 1) (2000 , 4001) (valid (route tt false 255 2 false ((4001 , 2003) ∷ (2003 , 2005) ∷ (2005 , 2006) ∷ []) (3 ∷ 3 ∷ 2 ∷ []))) + ⊕ extend (link true 4 0 false (2006 ∷ []) (floor 1 6 2 3 ∷ floor 2 3 1 2 ∷ floor 3 4 1 1 ∷ []) false false true 1) (2000 , 2003) (valid (route tt false 255 2 false ((2003 , 2003) ∷ (2003 , 2005) ∷ (2005 , 2006) ∷ []) (3 ∷ 3 ∷ 2 ∷ []))) + ≡ valid (route tt true 255 6 false ((2000 , 4001) ∷ (4001 , 2003) ∷ (2003 , 2005) ∷ (2005 , 2006) ∷ []) (1 ∷ 3 ∷ 3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 122 false (1001 ∷ []) ([]) true true true 3) (1000 , 2001) (valid (route false 0 2 true ((2001 , 1005) ∷ (1005 , 1003) ∷ []) (3 ∷ 2 ∷ []))) - ⊕ extend (link true 1 122 false (1001 ∷ []) ([]) true true true 3) (1000 , 2002) (valid (route false 0 2 true ((2002 , 1005) ∷ (1005 , 1003) ∷ []) (3 ∷ 2 ∷ []))) +_ : extend (link true 3 255 false (2003 ∷ []) (floor 2 1 1 3 ∷ floor 5 5 1 0 ∷ floor 6 5 2 2 ∷ []) false true false 2) (2000 , 2003) (valid (route tt false 127 11 false ((2003 , 2001) ∷ (2001 , 2005) ∷ (2005 , 2000) ∷ []) (1 ∷ 1 ∷ 1 ∷ []))) + ⊕ extend (link true 3 255 false (2003 ∷ []) (floor 2 1 1 3 ∷ floor 5 5 1 0 ∷ floor 6 5 2 2 ∷ []) false true false 2) (2000 , 2002) (valid (route tt false 127 11 false ((2002 , 2001) ∷ (2001 , 2005) ∷ (2005 , 2000) ∷ []) (1 ∷ 1 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 255 false (1004 ∷ 2001 ∷ []) (floor 5 2 1 1 ∷ floor 5 4 1 2 ∷ []) false false true 1) (1000 , 1002) (valid (route false 0 0 false ((1002 , 1005) ∷ (1005 , 2004) ∷ (2004 , 2006) ∷ (2006 , 1000) ∷ []) (3 ∷ 1 ∷ 3 ∷ 1 ∷ []))) - ⊕ extend (link true 1 255 false (1004 ∷ 2001 ∷ []) (floor 5 2 1 1 ∷ floor 5 4 1 2 ∷ []) false false true 1) (1000 , 2005) (valid (route false 0 0 false ((2005 , 1005) ∷ (1005 , 2004) ∷ (2004 , 2006) ∷ (2006 , 1000) ∷ []) (3 ∷ 1 ∷ 3 ∷ 1 ∷ []))) +_ : extend (link true 4 255 true (4001 ∷ 2004 ∷ []) (floor 2 1 2 0 ∷ floor 3 2 2 1 ∷ floor 6 2 1 1 ∷ []) false false false 2) (2000 , 2006) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 4 255 true (4001 ∷ 2004 ∷ []) (floor 2 1 2 0 ∷ floor 3 2 2 1 ∷ floor 6 2 1 1 ∷ []) false false false 2) (2000 , 2005) (valid (route tt false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 4 0 true (1002 ∷ []) (floor 1 4 2 1 ∷ floor 5 3 2 2 ∷ floor 6 5 1 3 ∷ []) false false true 3) (1000 , 1001) (valid (route false 127 5 false ((1001 , 1016) ∷ (1016 , 1034) ∷ (1034 , 2001) ∷ (2001 , 2027) ∷ (2027 , 2037) ∷ (2037 , 1007) ∷ (1007 , 1022) ∷ (1022 , 1015) ∷ (1015 , 1014) ∷ (1014 , 1010) ∷ (1010 , 1033) ∷ (1033 , 2006) ∷ (2006 , 1023) ∷ (1023 , 1009) ∷ (1009 , 2039) ∷ (2039 , 2005) ∷ (2005 , 1026) ∷ (1026 , 1036) ∷ (1036 , 1031) ∷ (1031 , 2035) ∷ (2035 , 2024) ∷ (2024 , 2011) ∷ (2011 , 2018) ∷ (2018 , 1019) ∷ (1019 , 2008) ∷ (2008 , 1012) ∷ (1012 , 2013) ∷ (2013 , 2021) ∷ (2021 , 2032) ∷ (2032 , 2028) ∷ []) (1 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ []))) - ⊕ extend (link true 3 128 false (1002 ∷ []) (floor 1 4 2 1 ∷ floor 5 3 2 2 ∷ floor 6 5 1 3 ∷ []) true false false 3) (1000 , 1006) (valid (route true 122 2 false ((1006 , 1002) ∷ (1002 , 1003) ∷ []) (1 ∷ 2 ∷ []))) - ≡ valid (route true 127 9 false ((1000 , 1001) ∷ (1001 , 1016) ∷ (1016 , 1034) ∷ (1034 , 2001) ∷ (2001 , 2027) ∷ (2027 , 2037) ∷ (2037 , 1007) ∷ (1007 , 1022) ∷ (1022 , 1015) ∷ (1015 , 1014) ∷ (1014 , 1010) ∷ (1010 , 1033) ∷ (1033 , 2006) ∷ (2006 , 1023) ∷ (1023 , 1009) ∷ (1009 , 2039) ∷ (2039 , 2005) ∷ (2005 , 1026) ∷ (1026 , 1036) ∷ (1036 , 1031) ∷ (1031 , 2035) ∷ (2035 , 2024) ∷ (2024 , 2011) ∷ (2011 , 2018) ∷ (2018 , 1019) ∷ (1019 , 2008) ∷ (2008 , 1012) ∷ (1012 , 2013) ∷ (2013 , 2021) ∷ (2021 , 2032) ∷ (2032 , 2028) ∷ []) (3 ∷ 1 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 4 128 false ([]) (floor 2 1 1 1 ∷ floor 4 1 2 1 ∷ floor 6 0 2 0 ∷ []) false false true 1) (2000 , 4005) (valid (route tt false 127 7 true ((4005 , 4003) ∷ []) (3 ∷ []))) + ⊕ extend (link true 4 128 false ([]) (floor 2 1 1 1 ∷ floor 4 1 2 1 ∷ floor 6 0 2 0 ∷ []) false false true 1) (2000 , 4003) (valid (route tt false 127 7 true ((4003 , 4003) ∷ []) (3 ∷ []))) + ≡ valid (route tt false 128 11 true ((2000 , 4003) ∷ (4003 , 4003) ∷ []) (1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 255 false (1005 ∷ 2001 ∷ []) (floor 2 6 2 3 ∷ floor 5 0 1 2 ∷ floor 5 3 1 0 ∷ []) false false false 2) (1000 , 2002) (valid (route false 127 3 false ((2002 , 2005) ∷ (2005 , 2004) ∷ (2004 , 1003) ∷ []) (3 ∷ 2 ∷ 1 ∷ []))) - ⊕ extend (link true 3 127 false (1005 ∷ 2001 ∷ []) (floor 2 6 2 3 ∷ floor 5 0 1 2 ∷ floor 5 3 1 0 ∷ []) false false true 1) (1000 , 2005) (valid (route true 127 7 false ((2005 , 1000) ∷ (1000 , 1003) ∷ (1003 , 2006) ∷ []) (1 ∷ 2 ∷ 2 ∷ []))) - ≡ valid (route false 255 6 false ((1000 , 2002) ∷ (2002 , 2005) ∷ (2005 , 2004) ∷ (2004 , 1003) ∷ []) (2 ∷ 3 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 4 128 false (2002 ∷ []) (floor 1 4 1 3 ∷ floor 3 5 1 0 ∷ floor 5 3 2 2 ∷ []) false true false 3) (2000 , 4004) (valid (route tt false 122 5 false ((4004 , 2002) ∷ (2002 , 2005) ∷ (2005 , 4000) ∷ []) (1 ∷ 3 ∷ 1 ∷ []))) + ⊕ extend (link true 4 128 false (2002 ∷ []) (floor 1 4 1 3 ∷ floor 3 5 1 0 ∷ floor 5 3 2 2 ∷ []) true true false 3) (2000 , 2002) (valid (route tt false 122 5 false ((2002 , 2002) ∷ (2002 , 2005) ∷ (2005 , 4000) ∷ []) (1 ∷ 3 ∷ 1 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 2 128 true ([]) (floor 1 1 2 1 ∷ []) false false true 3) (1000 , 1004) (valid (route false 122 6 false ((1004 , 1003) ∷ []) (1 ∷ []))) - ⊕ extend (link true 2 127 false ([]) (floor 1 1 2 1 ∷ []) false false true 1) (1000 , 1002) (valid (route false 255 0 false ((1002 , 1006) ∷ []) (2 ∷ []))) - ≡ valid (route false 255 2 false ((1000 , 1002) ∷ (1002 , 1006) ∷ []) (1 ∷ 2 ∷ [])) +_ : extend (link true 3 0 false ([]) (floor 5 3 2 2 ∷ []) false false true 2) (2000 , 2002) (valid (route tt false 255 2 false ((2002 , 2000) ∷ (2000 , 4004) ∷ (4004 , 2005) ∷ (2005 , 4001) ∷ []) (2 ∷ 2 ∷ 3 ∷ 1 ∷ []))) + ⊕ extend (link true 3 0 false ([]) (floor 5 3 2 2 ∷ []) false false true 2) (2000 , 2006) (valid (route tt false 255 2 false ((2006 , 2000) ∷ (2000 , 4004) ∷ (4004 , 2005) ∷ (2005 , 4001) ∷ []) (2 ∷ 2 ∷ 3 ∷ 1 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 4 128 false (1001 ∷ []) (floor 4 3 2 0 ∷ []) false true false 3) (1000 , 2006) (valid (route false 122 5 false ((2006 , 1000) ∷ (1000 , 1002) ∷ []) (1 ∷ 3 ∷ []))) - ⊕ extend (link true 1 122 false (1001 ∷ []) (floor 4 3 2 0 ∷ []) false true false 2) (1000 , 1001) (valid (route false 255 10 false ((1001 , 2003) ∷ []) (3 ∷ []))) - ≡ valid (route true 255 11 false ((1000 , 1001) ∷ (1001 , 2003) ∷ []) (2 ∷ 3 ∷ [])) +_ : extend (link true 4 127 true ([]) (floor 3 2 1 2 ∷ floor 6 3 1 1 ∷ floor 6 4 1 1 ∷ []) false true true 3) (2000 , 4002) (valid (route tt false 0 0 true ((4002 , 5002) ∷ []) (0 ∷ []))) + ⊕ extend (link true 4 127 true ([]) (floor 3 2 1 2 ∷ floor 6 3 1 1 ∷ floor 6 4 1 1 ∷ []) true true true 3) (2000 , 4001) (valid (route tt false 0 0 true ((4001 , 5001) ∷ []) (0 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 3 122 false (1001 ∷ []) (floor 4 4 2 0 ∷ []) false true true 2) (1000 , 1006) (valid (route true 255 5 false ((1006 , 2006) ∷ (2006 , 1001) ∷ (1001 , 1003) ∷ (1003 , 2005) ∷ []) (3 ∷ 2 ∷ 2 ∷ 2 ∷ []))) - ⊕ extend (link true 1 128 false (1001 ∷ []) (floor 4 4 2 0 ∷ []) false false true 1) (1000 , 1004) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 128 1 false ((1000 , 1004) ∷ []) (1 ∷ [])) +_ : extend (link true 1 127 true ([]) (floor 4 5 1 2 ∷ floor 5 0 1 2 ∷ []) false true true 3) (2000 , 2001) (valid (route tt false 122 6 false ((2001 , 2039) ∷ (2039 , 2002) ∷ (2002 , 2027) ∷ (2027 , 4035) ∷ (4035 , 2015) ∷ (2015 , 4003) ∷ (4003 , 2008) ∷ (2008 , 2030) ∷ (2030 , 2013) ∷ (2013 , 4012) ∷ (4012 , 2038) ∷ (2038 , 4033) ∷ (4033 , 2007) ∷ (2007 , 2025) ∷ (2025 , 2017) ∷ (2017 , 2040) ∷ (2040 , 2026) ∷ (2026 , 2037) ∷ (2037 , 4011) ∷ (4011 , 4006) ∷ (4006 , 2031) ∷ (2031 , 2021) ∷ (2021 , 4036) ∷ (4036 , 2019) ∷ (2019 , 4004) ∷ (4004 , 4023) ∷ (4023 , 4022) ∷ (4022 , 4028) ∷ (4028 , 2020) ∷ (2020 , 2010) ∷ (2010 , 4018) ∷ []) (1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 1 127 true ([]) (floor 4 5 1 2 ∷ floor 5 0 1 2 ∷ []) true true true 3) (2000 , 4004) (valid (route tt false 122 6 false ((4004 , 2039) ∷ (2039 , 2002) ∷ (2002 , 2027) ∷ (2027 , 4035) ∷ (4035 , 2015) ∷ (2015 , 4003) ∷ (4003 , 2008) ∷ (2008 , 2030) ∷ (2030 , 2013) ∷ (2013 , 4012) ∷ (4012 , 2038) ∷ (2038 , 4033) ∷ (4033 , 2007) ∷ (2007 , 2025) ∷ (2025 , 2017) ∷ (2017 , 2040) ∷ (2040 , 2026) ∷ (2026 , 2037) ∷ (2037 , 4011) ∷ (4011 , 4006) ∷ (4006 , 2031) ∷ (2031 , 2021) ∷ (2021 , 4036) ∷ (4036 , 2019) ∷ (2019 , 4004) ∷ (4004 , 4023) ∷ (4023 , 4022) ∷ (4022 , 4028) ∷ (4028 , 2020) ∷ (2020 , 2010) ∷ (2010 , 4018) ∷ []) (1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 2 0 false ([]) (floor 0 2 1 3 ∷ floor 0 3 1 3 ∷ floor 5 1 1 2 ∷ []) false true true 3) (1000 , 1004) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 2 127 false ([]) (floor 0 2 1 3 ∷ floor 0 3 1 3 ∷ floor 5 1 1 2 ∷ []) false true true 3) (1000 , 2002) (valid (route false 255 2 true ((2002 , 2004) ∷ (2004 , 2005) ∷ []) (2 ∷ 3 ∷ []))) - ≡ valid (route false 0 2 false ((1000 , 1004) ∷ []) (3 ∷ [])) +_ : extend (link true 4 122 false (4004 ∷ 2005 ∷ []) (floor 1 6 1 0 ∷ floor 2 6 2 0 ∷ floor 5 3 2 1 ∷ []) false false true 2) (2000 , 2003) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 4 122 false (4004 ∷ 2005 ∷ []) (floor 1 6 1 0 ∷ floor 2 6 2 0 ∷ floor 5 3 2 1 ∷ []) true false true 2) (2000 , 4001) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 122 4 false ((2000 , 2003) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 2 122 true (2005 ∷ 2006 ∷ []) ([]) false false false 3) (1000 , 2001) (valid (route false 128 7 true ((2001 , 1006) ∷ (1006 , 1005) ∷ []) (1 ∷ 3 ∷ []))) - ⊕ extend (link true 2 255 false (2005 ∷ 2006 ∷ []) ([]) false false true 3) (1000 , 1003) (valid (route false 0 0 true ((1003 , 1006) ∷ (1006 , 1004) ∷ (1004 , 1001) ∷ []) (2 ∷ 1 ∷ 1 ∷ []))) - ≡ valid (route false 255 2 true ((1000 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1004) ∷ (1004 , 1001) ∷ []) (3 ∷ 2 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 2 0 false (2004 ∷ []) (floor 1 3 2 2 ∷ floor 3 0 1 0 ∷ floor 5 6 2 3 ∷ []) true false true 1) (2000 , 4001) (valid (route tt false 122 5 false ((4001 , 2005) ∷ (2005 , 2003) ∷ (2003 , 2002) ∷ (2002 , 4004) ∷ []) (3 ∷ 2 ∷ 1 ∷ 2 ∷ []))) + ⊕ extend (link true 2 0 false (2004 ∷ []) (floor 1 3 2 2 ∷ floor 3 0 1 0 ∷ floor 5 6 2 3 ∷ []) true false true 1) (2000 , 2001) (valid (route tt false 122 5 false ((2001 , 2005) ∷ (2005 , 2003) ∷ (2003 , 2002) ∷ (2002 , 4004) ∷ []) (3 ∷ 2 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route tt false 122 7 true ((2000 , 2001) ∷ (2001 , 2005) ∷ (2005 , 2003) ∷ (2003 , 2002) ∷ (2002 , 4004) ∷ []) (1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 128 true (1001 ∷ []) ([]) false false true 3) (1000 , 1005) (valid (route false 0 4 false ((1005 , 1000) ∷ []) (1 ∷ []))) - ⊕ extend (link true 3 127 false (1001 ∷ []) ([]) false false false 1) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) - ≡ invalid +_ : extend (link true 4 0 false ([]) ([]) false false true 2) (2000 , 4004) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 4 0 false ([]) ([]) true false true 2) (2000 , 2005) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 4 false ((2000 , 4004) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 1 122 false ([]) ([]) false false false 3) (1000 , 1002) (valid (route false 127 7 false ((1002 , 2006) ∷ (2006 , 2004) ∷ (2004 , 2003) ∷ []) (2 ∷ 2 ∷ 1 ∷ []))) - ⊕ extend (link true 1 122 false ([]) ([]) false false false 3) (1000 , 1005) (valid (route false 127 7 false ((1005 , 2006) ∷ (2006 , 2004) ∷ (2004 , 2003) ∷ []) (2 ∷ 2 ∷ 1 ∷ []))) - ≡ valid (route false 127 8 false ((1000 , 1002) ∷ (1002 , 2006) ∷ (2006 , 2004) ∷ (2004 , 2003) ∷ []) (3 ∷ 2 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 2 122 false (4002 ∷ 4005 ∷ []) ([]) false true true 3) (2000 , 2005) (valid (route tt true 122 10 false ((2005 , 2004) ∷ (2004 , 4006) ∷ (4006 , 4001) ∷ (4001 , 2000) ∷ []) (1 ∷ 3 ∷ 2 ∷ 2 ∷ []))) + ⊕ extend (link true 1 128 false (4002 ∷ 4005 ∷ []) ([]) false false true 2) (2000 , 4001) (valid (route tt false 0 4 false ((4001 , 2002) ∷ (2002 , 3002) ∷ []) (3 ∷ 0 ∷ []))) + ≡ valid (route tt false 128 5 false ((2000 , 4001) ∷ (4001 , 2002) ∷ (2002 , 3002) ∷ []) (2 ∷ 3 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 1 255 false ([]) (floor 2 3 1 0 ∷ floor 3 5 1 3 ∷ []) true false true 2) (1000 , 1006) (valid (route true 128 10 false ((1006 , 1005) ∷ (1005 , 1002) ∷ (1002 , 1004) ∷ (1004 , 1001) ∷ []) (1 ∷ 1 ∷ 2 ∷ 3 ∷ []))) - ⊕ extend (link true 1 255 false ([]) (floor 2 3 1 0 ∷ floor 3 5 1 3 ∷ []) true false true 2) (1000 , 2003) (valid (route true 128 10 false ((2003 , 1005) ∷ (1005 , 1002) ∷ (1002 , 1004) ∷ (1004 , 1001) ∷ []) (1 ∷ 1 ∷ 2 ∷ 3 ∷ []))) - ≡ valid (route true 255 11 true ((1000 , 2003) ∷ (2003 , 1005) ∷ (1005 , 1002) ∷ (1002 , 1004) ∷ (1004 , 1001) ∷ []) (2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 4 127 false (4001 ∷ 4002 ∷ []) (floor 5 5 1 2 ∷ floor 6 1 1 3 ∷ []) true false true 2) (2000 , 2002) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 4 127 false (4001 ∷ 4002 ∷ []) (floor 5 5 1 2 ∷ floor 6 1 1 3 ∷ []) false false true 2) (2000 , 4001) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 127 4 true ((2000 , 2002) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 4 255 false ([]) (floor 3 6 2 2 ∷ []) true false true 2) (1000 , 2001) (valid (route false 0 0 true ((2001 , 1003) ∷ (1003 , 2006) ∷ (2006 , 2005) ∷ (2005 , 2002) ∷ []) (2 ∷ 3 ∷ 1 ∷ 2 ∷ []))) - ⊕ extend (link true 4 255 false ([]) (floor 3 6 2 2 ∷ []) true false true 2) (1000 , 1002) (valid (route false 0 0 true ((1002 , 1003) ∷ (1003 , 2006) ∷ (2006 , 2005) ∷ (2005 , 2002) ∷ []) (2 ∷ 3 ∷ 1 ∷ 2 ∷ []))) +_ : extend (link true 1 122 false ([]) (floor 4 3 2 3 ∷ floor 5 4 1 3 ∷ floor 6 5 2 1 ∷ []) true true true 3) (2000 , 4002) (valid (route tt true 122 9 false ((4002 , 4006) ∷ (4006 , 4000) ∷ (4000 , 2003) ∷ (2003 , 2004) ∷ []) (3 ∷ 1 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 1 122 false ([]) (floor 4 3 2 3 ∷ floor 5 4 1 3 ∷ floor 6 5 2 1 ∷ []) true true true 3) (2000 , 2002) (valid (route tt true 122 9 false ((2002 , 4006) ∷ (4006 , 4000) ∷ (4000 , 2003) ∷ (2003 , 2004) ∷ []) (3 ∷ 1 ∷ 2 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 122 false (1003 ∷ 2005 ∷ []) (floor 1 2 2 1 ∷ []) true false false 2) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 2 127 false (1003 ∷ 2005 ∷ []) (floor 1 2 2 1 ∷ []) false false false 1) (1000 , 2002) (valid (route false 255 3 false ((2002 , 1004) ∷ (1004 , 1005) ∷ (1005 , 1000) ∷ (1000 , 2006) ∷ []) (1 ∷ 3 ∷ 2 ∷ 1 ∷ []))) +_ : extend (link true 2 255 false (2005 ∷ 4006 ∷ []) (floor 6 5 2 0 ∷ []) false false true 3) (2000 , 4003) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 2 255 false (2005 ∷ 4006 ∷ []) (floor 6 5 2 0 ∷ []) false false true 3) (2000 , 4004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 255 2 false ((2000 , 4003) ∷ []) (3 ∷ [])) +_ = refl + +_ : extend (link true 4 128 true ([]) ([]) true false true 2) (2000 , 2006) (valid (route tt false 128 3 false ((2006 , 4000) ∷ (4000 , 2002) ∷ (2002 , 4001) ∷ []) (3 ∷ 3 ∷ 2 ∷ []))) + ⊕ extend (link true 1 0 false ([]) ([]) false false true 1) (2000 , 2002) (valid (route tt false 122 7 false ((2002 , 4005) ∷ (4005 , 4001) ∷ (4001 , 2000) ∷ (2000 , 4003) ∷ []) (2 ∷ 1 ∷ 1 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 128 false (1005 ∷ []) (floor 1 5 2 1 ∷ floor 3 1 2 3 ∷ []) false true true 1) (1000 , 2001) (valid (route false 0 10 false ((2001 , 1005) ∷ (1005 , 1001) ∷ (1001 , 2006) ∷ []) (2 ∷ 3 ∷ 3 ∷ []))) - ⊕ extend (link true 4 255 false (1005 ∷ []) (floor 1 5 2 1 ∷ floor 3 1 2 3 ∷ []) true false true 2) (1000 , 1004) (valid (route false 122 3 false ((1004 , 1000) ∷ (1000 , 1006) ∷ (1006 , 1005) ∷ (1005 , 2002) ∷ []) (3 ∷ 3 ∷ 1 ∷ 1 ∷ []))) - ≡ valid (route true 128 14 false ((1000 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1001) ∷ (1001 , 2006) ∷ []) (1 ∷ 2 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 4 255 false ([]) (floor 1 4 1 1 ∷ floor 6 3 1 2 ∷ []) false true false 1) (2000 , 4003) (valid (route tt false 0 0 true ((4003 , 5003) ∷ []) (0 ∷ []))) + ⊕ extend (link true 2 127 false ([]) (floor 1 4 1 1 ∷ floor 6 3 1 2 ∷ []) false false true 3) (2000 , 2004) (valid (route tt false 0 4 false ((2004 , 4003) ∷ (4003 , 2005) ∷ (2005 , 4006) ∷ (4006 , 5006) ∷ []) (2 ∷ 1 ∷ 2 ∷ 0 ∷ []))) + ≡ valid (route tt false 127 6 false ((2000 , 2004) ∷ (2004 , 4003) ∷ (4003 , 2005) ∷ (2005 , 4006) ∷ (4006 , 5006) ∷ []) (3 ∷ 2 ∷ 1 ∷ 2 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 3 122 false ([]) ([]) true false false 2) (1000 , 2004) (valid (route false 0 9 true ((2004 , 1005) ∷ (1005 , 1002) ∷ (1002 , 2001) ∷ []) (3 ∷ 3 ∷ 3 ∷ []))) - ⊕ extend (link true 3 122 false ([]) ([]) true false false 2) (1000 , 1006) (valid (route false 0 9 true ((1006 , 1005) ∷ (1005 , 1002) ∷ (1002 , 2001) ∷ []) (3 ∷ 3 ∷ 3 ∷ []))) - ≡ valid (route false 122 12 true ((1000 , 2004) ∷ (2004 , 1005) ∷ (1005 , 1002) ∷ (1002 , 2001) ∷ []) (2 ∷ 3 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 4 127 false ([]) (floor 1 3 1 1 ∷ floor 4 1 1 0 ∷ floor 5 3 2 2 ∷ []) false true false 3) (2000 , 2001) (valid (route tt false 127 6 false ((2001 , 2002) ∷ (2002 , 2004) ∷ (2004 , 4003) ∷ (4003 , 4006) ∷ []) (2 ∷ 1 ∷ 2 ∷ 2 ∷ []))) + ⊕ extend (link true 4 127 false ([]) (floor 1 3 1 1 ∷ floor 4 1 1 0 ∷ floor 5 3 2 2 ∷ []) true true false 3) (2000 , 4003) (valid (route tt false 127 6 false ((4003 , 2002) ∷ (2002 , 2004) ∷ (2004 , 4003) ∷ (4003 , 4006) ∷ []) (2 ∷ 1 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route tt false 127 10 false ((2000 , 2001) ∷ (2001 , 2002) ∷ (2002 , 2004) ∷ (2004 , 4003) ∷ (4003 , 4006) ∷ []) (3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 2 122 false ([]) (floor 1 6 1 3 ∷ floor 4 1 2 3 ∷ floor 5 6 2 2 ∷ []) true false true 3) (1000 , 2001) (valid (route false 128 3 false ((2001 , 2003) ∷ []) (2 ∷ []))) - ⊕ extend (link true 2 122 false ([]) (floor 1 6 1 3 ∷ floor 4 1 2 3 ∷ floor 5 6 2 2 ∷ []) true false true 3) (1000 , 1005) (valid (route false 128 3 false ((1005 , 2003) ∷ []) (2 ∷ []))) - ≡ valid (route false 128 5 true ((1000 , 2001) ∷ (2001 , 2003) ∷ []) (3 ∷ 2 ∷ [])) +_ : extend (link true 2 128 false (2002 ∷ []) (floor 4 3 1 0 ∷ []) false false true 1) (2000 , 2001) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 2 128 false (2002 ∷ []) (floor 4 3 1 0 ∷ []) true false true 1) (2000 , 2005) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 128 2 false ((2000 , 2001) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 4 122 false (2003 ∷ []) ([]) false false true 3) (1000 , 1004) (valid (route true 0 1 false ((1004 , 2001) ∷ (2001 , 1002) ∷ (1002 , 1000) ∷ (1000 , 1006) ∷ []) (3 ∷ 3 ∷ 2 ∷ 1 ∷ []))) - ⊕ extend (link true 4 122 false (2003 ∷ []) ([]) false false true 3) (1000 , 2003) (valid (route true 0 1 false ((2003 , 2001) ∷ (2001 , 1002) ∷ (1002 , 1000) ∷ (1000 , 1006) ∷ []) (3 ∷ 3 ∷ 2 ∷ 1 ∷ []))) - ≡ invalid +_ : extend (link true 3 127 false ([]) (floor 3 1 1 1 ∷ floor 5 0 2 0 ∷ floor 6 6 2 2 ∷ []) false false true 1) (2000 , 4003) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 3 127 false ([]) (floor 3 1 1 1 ∷ floor 5 0 2 0 ∷ floor 6 6 2 2 ∷ []) true false true 1) (2000 , 2002) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 127 3 false ((2000 , 4003) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 4 122 false ([]) (floor 0 2 2 2 ∷ floor 1 2 1 3 ∷ []) false false true 3) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 4 122 false ([]) (floor 0 2 2 2 ∷ floor 1 2 1 3 ∷ []) false false true 3) (1000 , 1005) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 122 4 false ((1000 , 2001) ∷ []) (3 ∷ [])) +_ : extend (link true 4 255 false (2003 ∷ []) (floor 1 5 2 0 ∷ floor 2 4 2 0 ∷ floor 5 1 1 0 ∷ []) false false true 1) (2000 , 4004) (valid (route tt false 0 0 true ((4004 , 5004) ∷ []) (0 ∷ []))) + ⊕ extend (link true 4 255 false (2003 ∷ []) (floor 1 5 2 0 ∷ floor 2 4 2 0 ∷ floor 5 1 1 0 ∷ []) true false true 1) (2000 , 2004) (valid (route tt false 0 0 true ((2004 , 3004) ∷ []) (0 ∷ []))) + ≡ valid (route tt false 255 4 true ((2000 , 2004) ∷ (2004 , 3004) ∷ []) (1 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 4 128 true (1006 ∷ []) (floor 2 2 2 2 ∷ []) true false true 2) (1000 , 2006) (valid (route true 127 11 false ((2006 , 1005) ∷ []) (3 ∷ []))) - ⊕ extend (link true 4 128 true (1006 ∷ []) (floor 2 2 2 2 ∷ []) true false true 2) (1000 , 2004) (valid (route true 127 11 false ((2004 , 1005) ∷ []) (3 ∷ []))) - ≡ valid (route true 128 15 true ((1000 , 2004) ∷ (2004 , 1005) ∷ []) (2 ∷ 3 ∷ [])) +_ : extend (link true 3 127 false ([]) (floor 3 0 2 3 ∷ []) true false true 3) (2000 , 4003) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 3 127 false ([]) (floor 3 0 2 3 ∷ []) false false true 3) (2000 , 2003) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 127 3 false ((2000 , 2003) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 4 127 false (1003 ∷ 1006 ∷ []) (floor 1 6 1 2 ∷ []) true false true 3) (1000 , 2004) (valid (route false 255 8 true ((2004 , 2024) ∷ (2024 , 2037) ∷ (2037 , 2014) ∷ (2014 , 2006) ∷ (2006 , 2035) ∷ (2035 , 1031) ∷ (1031 , 1004) ∷ (1004 , 1032) ∷ (1032 , 2022) ∷ (2022 , 2001) ∷ (2001 , 2015) ∷ (2015 , 2030) ∷ (2030 , 2026) ∷ (2026 , 2034) ∷ (2034 , 1010) ∷ (1010 , 1011) ∷ (1011 , 2038) ∷ (2038 , 2021) ∷ (2021 , 2020) ∷ (2020 , 1027) ∷ (1027 , 2033) ∷ (2033 , 1029) ∷ (1029 , 1023) ∷ (1023 , 2005) ∷ (2005 , 1007) ∷ (1007 , 2040) ∷ (2040 , 1017) ∷ (1017 , 2003) ∷ (2003 , 1018) ∷ (1018 , 1036) ∷ (1036 , 1013) ∷ (1013 , 2028) ∷ []) (2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ []))) - ⊕ extend (link true 4 127 false (1003 ∷ 1006 ∷ []) (floor 1 6 1 2 ∷ []) true false true 3) (1000 , 2003) (valid (route false 255 8 true ((2003 , 2024) ∷ (2024 , 2037) ∷ (2037 , 2014) ∷ (2014 , 2006) ∷ (2006 , 2035) ∷ (2035 , 1031) ∷ (1031 , 1004) ∷ (1004 , 1032) ∷ (1032 , 2022) ∷ (2022 , 2001) ∷ (2001 , 2015) ∷ (2015 , 2030) ∷ (2030 , 2026) ∷ (2026 , 2034) ∷ (2034 , 1010) ∷ (1010 , 1011) ∷ (1011 , 2038) ∷ (2038 , 2021) ∷ (2021 , 2020) ∷ (2020 , 1027) ∷ (1027 , 2033) ∷ (2033 , 1029) ∷ (1029 , 1023) ∷ (1023 , 2005) ∷ (2005 , 1007) ∷ (1007 , 2040) ∷ (2040 , 1017) ∷ (1017 , 2003) ∷ (2003 , 1018) ∷ (1018 , 1036) ∷ (1036 , 1013) ∷ (1013 , 2028) ∷ []) (2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ []))) - ≡ invalid +_ : extend (link true 3 127 true ([]) ([]) true false true 3) (2000 , 4004) (valid (route tt false 255 7 true ((4004 , 2002) ∷ (2002 , 3002) ∷ []) (2 ∷ 0 ∷ []))) + ⊕ extend (link true 3 127 true ([]) ([]) true false true 3) (2000 , 2004) (valid (route tt false 255 7 true ((2004 , 2002) ∷ (2002 , 3002) ∷ []) (2 ∷ 0 ∷ []))) + ≡ valid (route tt true 255 10 true ((2000 , 2004) ∷ (2004 , 2002) ∷ (2002 , 3002) ∷ []) (3 ∷ 2 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 3 122 true (1001 ∷ 1002 ∷ []) (floor 0 2 2 1 ∷ floor 4 6 2 1 ∷ []) false false true 1) (1000 , 1002) (valid (route false 255 3 false ((1002 , 2006) ∷ (2006 , 1000) ∷ (1000 , 1005) ∷ []) (1 ∷ 2 ∷ 3 ∷ []))) - ⊕ extend (link true 4 122 false (1001 ∷ 1002 ∷ []) (floor 0 2 2 1 ∷ floor 4 6 2 1 ∷ []) true true false 2) (1000 , 2005) (valid (route true 0 6 false ((2005 , 2003) ∷ (2003 , 1000) ∷ []) (1 ∷ 2 ∷ []))) - ≡ invalid +_ : extend (link true 4 122 false (2003 ∷ 2004 ∷ []) ([]) false false true 3) (2000 , 4006) (valid (route tt true 255 8 false ((4006 , 4004) ∷ (4004 , 2003) ∷ (2003 , 4001) ∷ (4001 , 2002) ∷ []) (3 ∷ 3 ∷ 1 ∷ 1 ∷ []))) + ⊕ extend (link true 4 122 false (2003 ∷ 2004 ∷ []) ([]) false false true 3) (2000 , 2006) (valid (route tt true 255 8 false ((2006 , 4004) ∷ (4004 , 2003) ∷ (2003 , 4001) ∷ (4001 , 2002) ∷ []) (3 ∷ 3 ∷ 1 ∷ 1 ∷ []))) + ≡ valid (route tt true 255 12 false ((2000 , 2006) ∷ (2006 , 4004) ∷ (4004 , 2003) ∷ (2003 , 4001) ∷ (4001 , 2002) ∷ []) (3 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 255 false (1006 ∷ []) ([]) false true true 1) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 2 122 false (1006 ∷ []) ([]) false false true 2) (1000 , 2006) (valid (route false 127 11 true ((2006 , 2001) ∷ (2001 , 1006) ∷ (1006 , 1000) ∷ []) (3 ∷ 1 ∷ 2 ∷ []))) - ≡ valid (route false 255 4 false ((1000 , 2001) ∷ []) (1 ∷ [])) +_ : extend (link true 2 0 false ([]) (floor 4 0 1 0 ∷ floor 5 6 1 0 ∷ []) true false true 3) (2000 , 4001) (valid (route tt false 122 6 false ((4001 , 4006) ∷ (4006 , 4003) ∷ (4003 , 4000) ∷ (4000 , 4002) ∷ []) (2 ∷ 2 ∷ 1 ∷ 3 ∷ []))) + ⊕ extend (link true 2 127 false ([]) (floor 4 0 1 0 ∷ floor 5 6 1 0 ∷ []) false false true 2) (2000 , 2001) (valid (route tt false 0 0 true ((2001 , 3001) ∷ []) (0 ∷ []))) + ≡ valid (route tt false 127 2 true ((2000 , 2001) ∷ (2001 , 3001) ∷ []) (2 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 3 255 true ([]) (floor 0 1 1 0 ∷ floor 3 4 2 2 ∷ []) false true true 1) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 3 255 true ([]) (floor 0 1 1 0 ∷ floor 3 4 2 2 ∷ []) false true true 1) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 255 3 false ((1000 , 2004) ∷ []) (1 ∷ [])) +_ : extend (link true 2 128 false (4003 ∷ 4005 ∷ []) (floor 2 4 2 2 ∷ floor 3 1 1 0 ∷ floor 6 6 1 0 ∷ []) false false false 2) (2000 , 2003) (valid (route tt false 0 0 true ((2003 , 4005) ∷ []) (2 ∷ []))) + ⊕ extend (link true 3 0 true (4003 ∷ 4005 ∷ []) (floor 2 4 2 2 ∷ floor 3 1 1 0 ∷ floor 6 6 1 0 ∷ []) false true false 1) (2000 , 4004) (valid (route tt false 0 4 true ((4004 , 2003) ∷ []) (3 ∷ []))) + ≡ valid (route tt true 128 2 true ((2000 , 2003) ∷ (2003 , 4005) ∷ []) (2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 2 127 false (2005 ∷ 2006 ∷ []) (floor 5 6 1 2 ∷ []) false true true 1) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 2 127 false (2005 ∷ 2006 ∷ []) (floor 5 6 1 2 ∷ []) false true true 1) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 127 2 false ((1000 , 2001) ∷ []) (1 ∷ [])) +_ : extend (link true 4 122 true (4004 ∷ []) ([]) true false true 2) (2000 , 2002) (valid (route tt true 255 1 true ((2002 , 4006) ∷ (4006 , 2000) ∷ (2000 , 4001) ∷ (4001 , 5001) ∷ []) (1 ∷ 3 ∷ 2 ∷ 0 ∷ []))) + ⊕ extend (link true 4 122 false (4004 ∷ []) ([]) true true true 1) (2000 , 4006) (valid (route tt true 127 11 true ((4006 , 2004) ∷ []) (1 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 1 128 false (1004 ∷ []) ([]) true false true 1) (1000 , 1001) (valid (route false 0 7 false ((1001 , 2003) ∷ []) (1 ∷ []))) - ⊕ extend (link true 4 122 true (1004 ∷ []) ([]) true false true 2) (1000 , 1005) (valid (route true 255 1 true ((1005 , 2006) ∷ (2006 , 1003) ∷ (1003 , 2001) ∷ []) (1 ∷ 3 ∷ 2 ∷ []))) - ≡ valid (route false 128 8 true ((1000 , 1001) ∷ (1001 , 2003) ∷ []) (1 ∷ 1 ∷ [])) +_ : extend (link true 2 255 true ([]) (floor 6 1 2 0 ∷ []) false false true 1) (2000 , 4003) (valid (route tt false 122 11 true ((4003 , 4000) ∷ (4000 , 2005) ∷ (2005 , 2002) ∷ (2002 , 2001) ∷ []) (1 ∷ 2 ∷ 3 ∷ 1 ∷ []))) + ⊕ extend (link true 2 255 true ([]) (floor 6 1 2 0 ∷ []) false false true 1) (2000 , 2005) (valid (route tt false 122 11 true ((2005 , 2128) ∷ (2128 , 4000) ∷ (4000 , 2005) ∷ (2005 , 2002) ∷ (2002 , 2001) ∷ []) (1 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 4 128 true ([]) ([]) false true true 3) (1000 , 2004) (valid (route true 127 10 false ((2004 , 2003) ∷ (2003 , 1004) ∷ (1004 , 1000) ∷ []) (3 ∷ 1 ∷ 3 ∷ []))) - ⊕ extend (link true 4 128 true ([]) ([]) false true true 3) (1000 , 2001) (valid (route true 127 10 false ((2001 , 2003) ∷ (2003 , 1004) ∷ (1004 , 1000) ∷ []) (3 ∷ 1 ∷ 3 ∷ []))) +_ : extend (link true 3 255 false (4001 ∷ []) (floor 2 1 1 1 ∷ []) true true true 3) (2000 , 2006) (valid (route tt false 0 0 true ((2006 , 3006) ∷ []) (0 ∷ []))) + ⊕ extend (link true 4 127 false (4001 ∷ []) (floor 2 1 1 1 ∷ []) true true true 1) (2000 , 4005) (valid (route tt true 122 2 true ((4005 , 4006) ∷ (4006 , 4000) ∷ (4000 , 4002) ∷ []) (3 ∷ 1 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 128 false ([]) (floor 0 3 1 2 ∷ floor 2 2 2 1 ∷ []) false false true 3) (1000 , 1003) (valid (route false 255 4 false ((1003 , 2001) ∷ (2001 , 1000) ∷ (1000 , 2003) ∷ []) (1 ∷ 2 ∷ 2 ∷ []))) - ⊕ extend (link true 3 0 false ([]) (floor 0 3 1 2 ∷ floor 2 2 2 1 ∷ []) false false false 3) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) +_ : extend (link true 2 127 true (4002 ∷ []) (floor 1 6 2 0 ∷ []) true false true 2) (2000 , 4002) (valid (route tt false 128 1 false ((4002 , 2005) ∷ (2005 , 4000) ∷ (4000 , 4003) ∷ (4003 , 4001) ∷ []) (3 ∷ 2 ∷ 1 ∷ 1 ∷ []))) + ⊕ extend (link true 2 127 true (4002 ∷ []) (floor 1 6 2 0 ∷ []) true false true 2) (2000 , 4005) (valid (route tt false 128 1 false ((4005 , 2005) ∷ (2005 , 4000) ∷ (4000 , 4003) ∷ (4003 , 4001) ∷ []) (3 ∷ 2 ∷ 1 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 0 false (2002 ∷ []) (floor 2 2 2 1 ∷ []) false true true 2) (1000 , 1006) (valid (route false 0 7 false ((1006 , 1001) ∷ (1001 , 1000) ∷ (1000 , 2003) ∷ []) (2 ∷ 1 ∷ 1 ∷ []))) - ⊕ extend (link true 3 0 false (2002 ∷ []) (floor 2 2 2 1 ∷ []) false true true 2) (1000 , 2001) (valid (route false 0 7 false ((2001 , 1001) ∷ (1001 , 1000) ∷ (1000 , 2003) ∷ []) (2 ∷ 1 ∷ 1 ∷ []))) +_ : extend (link true 1 122 false (4006 ∷ []) (floor 1 6 2 2 ∷ floor 3 6 2 1 ∷ floor 5 4 1 2 ∷ []) false true true 2) (2000 , 4002) (valid (route tt true 122 4 false ((4002 , 4000) ∷ (4000 , 2005) ∷ (2005 , 4004) ∷ []) (1 ∷ 2 ∷ 3 ∷ []))) + ⊕ extend (link true 1 0 true (4006 ∷ []) (floor 1 6 2 2 ∷ floor 3 6 2 1 ∷ floor 5 4 1 2 ∷ []) false false false 3) (2000 , 2002) (valid (route tt true 128 2 true ((2002 , 4003) ∷ (4003 , 2006) ∷ (2006 , 4004) ∷ []) (2 ∷ 1 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 122 false ([]) (floor 0 0 1 2 ∷ floor 2 6 2 0 ∷ floor 3 1 1 1 ∷ []) false false false 2) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 1 255 false ([]) (floor 0 0 1 2 ∷ floor 2 6 2 0 ∷ floor 3 1 1 1 ∷ []) false true true 1) (1000 , 2001) (valid (route true 122 2 false ((2001 , 2004) ∷ (2004 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2003) ∷ []) (3 ∷ 2 ∷ 3 ∷ 1 ∷ []))) - ≡ valid (route true 255 3 false ((1000 , 2001) ∷ (2001 , 2004) ∷ (2004 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2003) ∷ []) (1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ [])) +_ : extend (link true 3 255 false (4004 ∷ []) (floor 1 3 2 0 ∷ floor 4 5 1 2 ∷ []) false false true 2) (2000 , 4005) (valid (route tt false 0 0 true ((4005 , 5005) ∷ []) (0 ∷ []))) + ⊕ extend (link true 3 255 false (4004 ∷ []) (floor 1 3 2 0 ∷ floor 4 5 1 2 ∷ []) false false true 2) (2000 , 4004) (valid (route tt false 0 0 true ((4004 , 5004) ∷ []) (0 ∷ []))) + ≡ valid (route tt false 255 3 true ((2000 , 4005) ∷ (4005 , 5005) ∷ []) (2 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 3 128 true (1003 ∷ []) (floor 4 4 1 1 ∷ []) false false true 2) (1000 , 2004) (valid (route false 0 5 false ((2004 , 2005) ∷ (2005 , 2003) ∷ []) (1 ∷ 1 ∷ []))) - ⊕ extend (link true 1 122 false (1003 ∷ []) (floor 4 4 1 1 ∷ []) false false true 3) (1000 , 2002) (valid (route false 127 10 true ((2002 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1005) ∷ (1005 , 1000) ∷ []) (2 ∷ 1 ∷ 3 ∷ 1 ∷ []))) - ≡ valid (route true 128 8 false ((1000 , 2004) ∷ (2004 , 2005) ∷ (2005 , 2003) ∷ []) (2 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 2 0 false (4003 ∷ []) (floor 2 3 2 1 ∷ floor 6 0 2 0 ∷ []) true true true 1) (2000 , 2003) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 4 122 false (4003 ∷ []) (floor 2 3 2 1 ∷ floor 6 0 2 0 ∷ []) true false true 3) (2000 , 2001) (valid (route tt false 128 9 false ((2001 , 2005) ∷ (2005 , 2003) ∷ (2003 , 4004) ∷ []) (2 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route tt false 0 2 true ((2000 , 2003) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 3 255 false ([]) (floor 3 2 1 2 ∷ []) false false true 3) (1000 , 2001) (valid (route false 0 8 false ((2001 , 2006) ∷ []) (1 ∷ []))) - ⊕ extend (link true 4 0 false ([]) (floor 3 2 1 2 ∷ []) false true true 1) (1000 , 1003) (valid (route false 255 3 false ((1003 , 2003) ∷ (2003 , 1000) ∷ (1000 , 1006) ∷ []) (1 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route false 255 11 false ((1000 , 2001) ∷ (2001 , 2006) ∷ []) (3 ∷ 1 ∷ [])) +_ : extend (link true 1 0 false ([]) (floor 2 6 1 2 ∷ floor 3 1 1 0 ∷ floor 6 1 2 2 ∷ []) false false false 3) (2000 , 4005) (valid (route tt false 0 0 true ((4005 , 5005) ∷ []) (0 ∷ []))) + ⊕ extend (link true 1 0 false ([]) (floor 2 6 1 2 ∷ floor 3 1 1 0 ∷ floor 6 1 2 2 ∷ []) false false false 3) (2000 , 2002) (valid (route tt false 0 0 true ((2002 , 3002) ∷ []) (0 ∷ []))) + ≡ valid (route tt false 0 1 true ((2000 , 2002) ∷ (2002 , 3002) ∷ []) (3 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 2 122 false (1005 ∷ 2002 ∷ []) (floor 0 3 2 0 ∷ []) false false true 3) (1000 , 1004) (valid (route true 0 8 false ((1004 , 2027) ∷ (2027 , 1012) ∷ (1012 , 1001) ∷ (1001 , 1008) ∷ (1008 , 1029) ∷ (1029 , 1033) ∷ (1033 , 1022) ∷ (1022 , 2014) ∷ (2014 , 2039) ∷ (2039 , 1035) ∷ (1035 , 1036) ∷ (1036 , 2011) ∷ (2011 , 1024) ∷ (1024 , 1015) ∷ (1015 , 1016) ∷ (1016 , 1034) ∷ (1034 , 1005) ∷ (1005 , 2006) ∷ (2006 , 2017) ∷ (2017 , 1020) ∷ (1020 , 2030) ∷ (2030 , 2025) ∷ (2025 , 2004) ∷ (2004 , 1019) ∷ (1019 , 2013) ∷ (2013 , 1040) ∷ (1040 , 2018) ∷ (2018 , 1009) ∷ (1009 , 2031) ∷ (2031 , 1026) ∷ []) (3 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ []))) - ⊕ extend (link true 2 127 false (1005 ∷ 2002 ∷ []) (floor 0 3 2 0 ∷ []) false false false 2) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 122 10 false ((1000 , 1004) ∷ (1004 , 2027) ∷ (2027 , 1012) ∷ (1012 , 1001) ∷ (1001 , 1008) ∷ (1008 , 1029) ∷ (1029 , 1033) ∷ (1033 , 1022) ∷ (1022 , 2014) ∷ (2014 , 2039) ∷ (2039 , 1035) ∷ (1035 , 1036) ∷ (1036 , 2011) ∷ (2011 , 1024) ∷ (1024 , 1015) ∷ (1015 , 1016) ∷ (1016 , 1034) ∷ (1034 , 1005) ∷ (1005 , 2006) ∷ (2006 , 2017) ∷ (2017 , 1020) ∷ (1020 , 2030) ∷ (2030 , 2025) ∷ (2025 , 2004) ∷ (2004 , 1019) ∷ (1019 , 2013) ∷ (2013 , 1040) ∷ (1040 , 2018) ∷ (2018 , 1009) ∷ (1009 , 2031) ∷ (2031 , 1026) ∷ []) (3 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 3 255 true ([]) (floor 1 3 2 2 ∷ floor 4 0 2 1 ∷ floor 4 5 2 1 ∷ []) false false true 2) (2000 , 2002) (valid (route tt true 255 11 true ((2002 , 4001) ∷ (4001 , 5001) ∷ []) (2 ∷ 0 ∷ []))) + ⊕ extend (link true 3 255 true ([]) (floor 1 3 2 2 ∷ floor 4 0 2 1 ∷ floor 4 5 2 1 ∷ []) false false true 2) (2000 , 2003) (valid (route tt true 255 11 true ((2003 , 2114) ∷ (2114 , 4001) ∷ (4001 , 5001) ∷ []) (2 ∷ 1 ∷ 0 ∷ []))) + ≡ valid (route tt true 255 14 true ((2000 , 2002) ∷ (2002 , 4001) ∷ (4001 , 5001) ∷ []) (2 ∷ 2 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 4 255 false (1002 ∷ 2002 ∷ []) (floor 1 1 1 2 ∷ floor 3 3 2 1 ∷ floor 3 5 2 3 ∷ []) true false true 3) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 4 255 false (1002 ∷ 2002 ∷ []) (floor 1 1 1 2 ∷ floor 3 3 2 1 ∷ floor 3 5 2 3 ∷ []) true false true 3) (1000 , 1005) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 255 4 true ((1000 , 2001) ∷ []) (3 ∷ [])) +_ : extend (link true 1 0 false (2003 ∷ 4006 ∷ []) ([]) false true true 2) (2000 , 2002) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 1 0 false (2003 ∷ 4006 ∷ []) ([]) false true true 2) (2000 , 4002) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 0 1 false ((2000 , 2002) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 1 127 false (2002 ∷ []) ([]) false false true 3) (1000 , 1004) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 3 255 false (2002 ∷ []) ([]) false false false 3) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 127 1 false ((1000 , 1004) ∷ []) (3 ∷ [])) +_ : extend (link true 1 0 true (2002 ∷ 4005 ∷ []) (floor 1 2 2 2 ∷ floor 2 5 2 0 ∷ []) false false true 1) (2000 , 4004) (valid (route tt false 0 0 true ((4004 , 5004) ∷ []) (0 ∷ []))) + ⊕ extend (link true 1 0 true (2002 ∷ 4005 ∷ []) (floor 1 2 2 2 ∷ floor 2 5 2 0 ∷ []) true false true 1) (2000 , 4002) (valid (route tt false 0 0 true ((4002 , 5002) ∷ []) (0 ∷ []))) + ≡ valid (route tt true 0 1 true ((2000 , 4002) ∷ (4002 , 5002) ∷ []) (1 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 3 255 false (1003 ∷ []) (floor 2 0 2 0 ∷ floor 3 3 2 2 ∷ floor 3 4 1 2 ∷ []) false true true 2) (1000 , 1006) (valid (route false 122 7 false ((1006 , 2005) ∷ (2005 , 1003) ∷ (1003 , 1001) ∷ []) (3 ∷ 2 ∷ 1 ∷ []))) - ⊕ extend (link true 3 0 false (1003 ∷ []) (floor 2 0 2 0 ∷ floor 3 3 2 2 ∷ floor 3 4 1 2 ∷ []) true false true 2) (1000 , 2003) (valid (route true 128 1 true ((2003 , 2004) ∷ (2004 , 1001) ∷ []) (1 ∷ 2 ∷ []))) - ≡ valid (route true 128 4 true ((1000 , 2003) ∷ (2003 , 2004) ∷ (2004 , 1001) ∷ []) (2 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 4 128 false (2005 ∷ []) (floor 1 6 1 2 ∷ floor 2 2 2 2 ∷ floor 3 5 1 3 ∷ []) false false false 3) (2000 , 4004) (valid (route tt false 0 0 true ((4004 , 5004) ∷ []) (0 ∷ []))) + ⊕ extend (link true 4 128 false (2005 ∷ []) (floor 1 6 1 2 ∷ floor 2 2 2 2 ∷ floor 3 5 1 3 ∷ []) false false false 3) (2000 , 4006) (valid (route tt false 0 0 true ((4006 , 5006) ∷ []) (0 ∷ []))) + ≡ valid (route tt false 128 4 true ((2000 , 4004) ∷ (4004 , 5004) ∷ []) (3 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 1 128 false (1004 ∷ []) (floor 1 2 1 1 ∷ floor 2 1 2 3 ∷ floor 4 2 2 2 ∷ []) false true true 1) (1000 , 1002) (valid (route false 255 9 false ((1002 , 1001) ∷ (1001 , 1005) ∷ []) (3 ∷ 2 ∷ []))) - ⊕ extend (link true 4 127 false (1004 ∷ []) (floor 1 2 1 1 ∷ floor 2 1 2 3 ∷ floor 4 2 2 2 ∷ []) false true false 3) (1000 , 1006) (valid (route false 255 0 false ((1006 , 1000) ∷ []) (1 ∷ []))) - ≡ invalid +_ : extend (link true 3 0 false (2002 ∷ 2006 ∷ []) (floor 4 3 1 2 ∷ floor 5 2 2 1 ∷ []) false false true 1) (2000 , 2002) (valid (route tt true 0 11 false ((2002 , 4004) ∷ (4004 , 2001) ∷ (2001 , 4005) ∷ []) (2 ∷ 2 ∷ 2 ∷ []))) + ⊕ extend (link true 3 0 false (2002 ∷ 2006 ∷ []) (floor 4 3 1 2 ∷ floor 5 2 2 1 ∷ []) true false true 1) (2000 , 2003) (valid (route tt true 0 11 false ((2003 , 4004) ∷ (4004 , 2001) ∷ (2001 , 4005) ∷ []) (2 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route tt true 0 14 false ((2000 , 2002) ∷ (2002 , 4004) ∷ (4004 , 2001) ∷ (2001 , 4005) ∷ []) (1 ∷ 2 ∷ 2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 122 false (1001 ∷ []) (floor 2 1 1 3 ∷ []) false false true 1) (1000 , 1004) (valid (route true 127 10 true ((1004 , 2003) ∷ (2003 , 1006) ∷ (1006 , 1001) ∷ []) (2 ∷ 1 ∷ 1 ∷ []))) - ⊕ extend (link true 3 122 false (1001 ∷ []) (floor 2 1 1 3 ∷ []) false false true 1) (1000 , 2005) (valid (route true 127 10 true ((2005 , 2003) ∷ (2003 , 1006) ∷ (1006 , 1001) ∷ []) (2 ∷ 1 ∷ 1 ∷ []))) - ≡ valid (route true 127 13 true ((1000 , 1004) ∷ (1004 , 2003) ∷ (2003 , 1006) ∷ (1006 , 1001) ∷ []) (1 ∷ 2 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 2 122 false ([]) (floor 1 6 2 3 ∷ floor 5 5 2 0 ∷ []) false true false 2) (2000 , 4004) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 2 128 true ([]) (floor 1 6 2 3 ∷ floor 5 5 2 0 ∷ []) true true true 3) (2000 , 2001) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 128 2 true ((2000 , 2001) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 4 127 false (1003 ∷ 2003 ∷ []) ([]) true false true 1) (1000 , 2001) (valid (route false 255 9 false ((2001 , 1002) ∷ (1002 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2004) ∷ []) (2 ∷ 1 ∷ 2 ∷ 2 ∷ []))) - ⊕ extend (link true 4 127 false (1003 ∷ 2003 ∷ []) ([]) true false true 1) (1000 , 2006) (valid (route false 255 9 false ((2006 , 1002) ∷ (1002 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2004) ∷ []) (2 ∷ 1 ∷ 2 ∷ 2 ∷ []))) - ≡ valid (route false 255 13 true ((1000 , 2001) ∷ (2001 , 1002) ∷ (1002 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2004) ∷ []) (1 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ [])) +_ : extend (link true 3 0 false ([]) (floor 2 4 2 3 ∷ []) false false true 1) (2000 , 2003) (valid (route tt false 0 7 true ((2003 , 2005) ∷ []) (3 ∷ []))) + ⊕ extend (link true 3 0 false ([]) (floor 2 4 2 3 ∷ []) false false true 1) (2000 , 2005) (valid (route tt false 0 7 true ((2005 , 2175) ∷ (2175 , 2005) ∷ []) (3 ∷ 1 ∷ []))) + ≡ valid (route tt false 0 10 true ((2000 , 2003) ∷ (2003 , 2005) ∷ []) (1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 122 false (1006 ∷ 2003 ∷ []) (floor 5 0 2 1 ∷ []) false true false 2) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 3 122 false (1006 ∷ 2003 ∷ []) (floor 5 0 2 1 ∷ []) false true false 2) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) +_ : extend (link true 4 127 false (2002 ∷ []) (floor 1 4 1 3 ∷ floor 4 4 1 3 ∷ floor 5 6 2 3 ∷ []) false true false 3) (2000 , 4005) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 4 127 false (2002 ∷ []) (floor 1 4 1 3 ∷ floor 4 4 1 3 ∷ floor 5 6 2 3 ∷ []) false true false 3) (2000 , 2002) (valid (route tt false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 3 255 false (1003 ∷ 1004 ∷ []) (floor 0 6 2 2 ∷ []) false false true 1) (1000 , 2001) (valid (route true 255 5 false ((2001 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1002) ∷ []) (1 ∷ 2 ∷ 2 ∷ 3 ∷ []))) - ⊕ extend (link true 3 128 false (1003 ∷ 1004 ∷ []) (floor 0 6 2 2 ∷ []) false false true 3) (1000 , 2003) (valid (route false 127 8 true ((2003 , 1002) ∷ (1002 , 1005) ∷ (1005 , 1003) ∷ []) (2 ∷ 2 ∷ 2 ∷ []))) - ≡ valid (route true 128 11 true ((1000 , 2003) ∷ (2003 , 1002) ∷ (1002 , 1005) ∷ (1005 , 1003) ∷ []) (3 ∷ 2 ∷ 2 ∷ 2 ∷ [])) +_ : extend (link true 3 122 false (2001 ∷ []) (floor 4 1 2 3 ∷ []) true true true 1) (2000 , 4004) (valid (route tt false 127 9 false ((4004 , 4001) ∷ (4001 , 4005) ∷ (4005 , 4003) ∷ (4003 , 2006) ∷ []) (2 ∷ 3 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 3 122 false (2001 ∷ []) (floor 4 1 2 3 ∷ []) false true true 1) (2000 , 4005) (valid (route tt false 127 9 false ((4005 , 4001) ∷ (4001 , 4005) ∷ (4005 , 4003) ∷ (4003 , 2006) ∷ []) (2 ∷ 3 ∷ 2 ∷ 1 ∷ []))) + ≡ valid (route tt false 127 12 false ((2000 , 4005) ∷ (4005 , 4001) ∷ (4001 , 4005) ∷ (4005 , 4003) ∷ (4003 , 2006) ∷ []) (1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 3 122 false (1001 ∷ 1003 ∷ []) ([]) false true true 3) (1000 , 2003) (valid (route false 127 3 false ((2003 , 1001) ∷ (1001 , 1004) ∷ []) (3 ∷ 1 ∷ []))) - ⊕ extend (link true 3 122 false (1001 ∷ 1003 ∷ []) ([]) false true true 3) (1000 , 2004) (valid (route false 127 3 false ((2004 , 1001) ∷ (1001 , 1004) ∷ []) (3 ∷ 1 ∷ []))) - ≡ valid (route true 127 6 false ((1000 , 2003) ∷ (2003 , 1001) ∷ (1001 , 1004) ∷ []) (3 ∷ 3 ∷ 1 ∷ [])) +_ : extend (link true 1 127 false (2005 ∷ []) (floor 4 1 2 3 ∷ floor 5 5 2 2 ∷ floor 6 5 2 1 ∷ []) false false true 2) (2000 , 2002) (valid (route tt false 128 8 true ((2002 , 4035) ∷ (4035 , 4011) ∷ (4011 , 2036) ∷ (2036 , 4013) ∷ (4013 , 2034) ∷ (2034 , 2018) ∷ (2018 , 2010) ∷ (2010 , 4015) ∷ (4015 , 4019) ∷ (4019 , 2038) ∷ (2038 , 2031) ∷ (2031 , 4003) ∷ (4003 , 4026) ∷ (4026 , 2016) ∷ (2016 , 2030) ∷ (2030 , 2012) ∷ (2012 , 2021) ∷ (2021 , 2009) ∷ (2009 , 4040) ∷ (4040 , 4014) ∷ (4014 , 2039) ∷ (2039 , 4007) ∷ (4007 , 2001) ∷ (2001 , 4023) ∷ (4023 , 2037) ∷ (2037 , 4024) ∷ (4024 , 4017) ∷ (4017 , 4027) ∷ (4027 , 2006) ∷ (2006 , 4005) ∷ (4005 , 4028) ∷ (4028 , 4032) ∷ []) (1 ∷ 3 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 3 ∷ []))) + ⊕ extend (link true 1 127 false (2005 ∷ []) (floor 4 1 2 3 ∷ floor 5 5 2 2 ∷ floor 6 5 2 1 ∷ []) false false true 2) (2000 , 4004) (valid (route tt false 128 8 true ((4004 , 4035) ∷ (4035 , 4011) ∷ (4011 , 2036) ∷ (2036 , 4013) ∷ (4013 , 2034) ∷ (2034 , 2018) ∷ (2018 , 2010) ∷ (2010 , 4015) ∷ (4015 , 4019) ∷ (4019 , 2038) ∷ (2038 , 2031) ∷ (2031 , 4003) ∷ (4003 , 4026) ∷ (4026 , 2016) ∷ (2016 , 2030) ∷ (2030 , 2012) ∷ (2012 , 2021) ∷ (2021 , 2009) ∷ (2009 , 4040) ∷ (4040 , 4014) ∷ (4014 , 2039) ∷ (2039 , 4007) ∷ (4007 , 2001) ∷ (2001 , 4023) ∷ (4023 , 2037) ∷ (2037 , 4024) ∷ (4024 , 4017) ∷ (4017 , 4027) ∷ (4027 , 2006) ∷ (2006 , 4005) ∷ (4005 , 4028) ∷ (4028 , 4032) ∷ []) (1 ∷ 3 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 3 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 1 255 false (2005 ∷ []) (floor 0 6 1 1 ∷ []) false false true 3) (1000 , 2006) (valid (route false 122 4 false ((2006 , 2039) ∷ (2039 , 1030) ∷ (1030 , 2029) ∷ (2029 , 1014) ∷ (1014 , 1040) ∷ (1040 , 2023) ∷ (2023 , 1011) ∷ (1011 , 1026) ∷ (1026 , 2037) ∷ (2037 , 1010) ∷ (1010 , 2024) ∷ (2024 , 2020) ∷ (2020 , 1022) ∷ (1022 , 1038) ∷ (1038 , 2015) ∷ (2015 , 2008) ∷ (2008 , 1019) ∷ (1019 , 1032) ∷ (1032 , 2025) ∷ (2025 , 2002) ∷ (2002 , 1027) ∷ (1027 , 2004) ∷ (2004 , 2031) ∷ (2031 , 2034) ∷ (2034 , 2001) ∷ (2001 , 1035) ∷ (1035 , 1021) ∷ (1021 , 1033) ∷ (1033 , 1012) ∷ (1012 , 2036) ∷ (2036 , 1003) ∷ []) (2 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ []))) - ⊕ extend (link true 1 255 false (2005 ∷ []) (floor 0 6 1 1 ∷ []) false false true 3) (1000 , 2004) (valid (route false 122 4 false ((2004 , 2039) ∷ (2039 , 1030) ∷ (1030 , 2029) ∷ (2029 , 1014) ∷ (1014 , 1040) ∷ (1040 , 2023) ∷ (2023 , 1011) ∷ (1011 , 1026) ∷ (1026 , 2037) ∷ (2037 , 1010) ∷ (1010 , 2024) ∷ (2024 , 2020) ∷ (2020 , 1022) ∷ (1022 , 1038) ∷ (1038 , 2015) ∷ (2015 , 2008) ∷ (2008 , 1019) ∷ (1019 , 1032) ∷ (1032 , 2025) ∷ (2025 , 2002) ∷ (2002 , 1027) ∷ (1027 , 2004) ∷ (2004 , 2031) ∷ (2031 , 2034) ∷ (2034 , 2001) ∷ (2001 , 1035) ∷ (1035 , 1021) ∷ (1021 , 1033) ∷ (1033 , 1012) ∷ (1012 , 2036) ∷ (2036 , 1003) ∷ []) (2 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ []))) - ≡ invalid +_ : extend (link true 3 128 true (4003 ∷ []) (floor 2 4 2 1 ∷ []) true true true 1) (2000 , 4002) (valid (route tt true 128 3 false ((4002 , 4000) ∷ (4000 , 4006) ∷ []) (1 ∷ 1 ∷ []))) + ⊕ extend (link true 2 0 false (4003 ∷ []) (floor 2 4 2 1 ∷ []) true true true 1) (2000 , 2005) (valid (route tt true 127 7 false ((2005 , 2004) ∷ []) (2 ∷ []))) + ≡ valid (route tt true 127 9 true ((2000 , 2005) ∷ (2005 , 2004) ∷ []) (1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 127 true (1003 ∷ 2003 ∷ []) (floor 1 4 2 2 ∷ floor 1 5 1 3 ∷ floor 3 3 1 0 ∷ []) false false true 1) (1000 , 2005) (valid (route false 0 3 false ((2005 , 1002) ∷ (1002 , 2004) ∷ []) (1 ∷ 2 ∷ []))) - ⊕ extend (link true 1 127 true (1003 ∷ 2003 ∷ []) (floor 1 4 2 2 ∷ floor 1 5 1 3 ∷ floor 3 3 1 0 ∷ []) false false true 1) (1000 , 2003) (valid (route false 0 3 false ((2003 , 1002) ∷ (1002 , 2004) ∷ []) (1 ∷ 2 ∷ []))) - ≡ valid (route true 127 4 false ((1000 , 2003) ∷ (2003 , 1002) ∷ (1002 , 2004) ∷ []) (1 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 4 128 true (2001 ∷ 2002 ∷ []) (floor 2 0 2 2 ∷ floor 3 6 1 0 ∷ []) true false true 1) (2000 , 2003) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 4 128 true (2001 ∷ 2002 ∷ []) (floor 2 0 2 2 ∷ floor 3 6 1 0 ∷ []) true false true 1) (2000 , 4004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 128 4 true ((2000 , 2003) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 4 122 false ([]) (floor 1 5 2 3 ∷ floor 2 1 1 2 ∷ []) false false true 1) (1000 , 2005) (valid (route true 0 3 false ((2005 , 1004) ∷ []) (2 ∷ []))) - ⊕ extend (link true 4 122 false ([]) (floor 1 5 2 3 ∷ floor 2 1 1 2 ∷ []) false false true 1) (1000 , 2004) (valid (route true 0 3 false ((2004 , 1004) ∷ []) (2 ∷ []))) - ≡ valid (route true 122 7 false ((1000 , 2004) ∷ (2004 , 1004) ∷ []) (1 ∷ 2 ∷ [])) +_ : extend (link true 4 255 false (2002 ∷ 2006 ∷ []) (floor 2 4 2 1 ∷ floor 3 5 1 1 ∷ []) true false false 3) (2000 , 4006) (valid (route tt true 127 5 false ((4006 , 4005) ∷ (4005 , 4003) ∷ (4003 , 5003) ∷ []) (3 ∷ 1 ∷ 0 ∷ []))) + ⊕ extend (link true 1 255 false (2002 ∷ 2006 ∷ []) (floor 2 4 2 1 ∷ floor 3 5 1 1 ∷ []) false false false 1) (2000 , 2006) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 255 9 true ((2000 , 4006) ∷ (4006 , 4005) ∷ (4005 , 4003) ∷ (4003 , 5003) ∷ []) (3 ∷ 3 ∷ 1 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 3 0 false ([]) (floor 5 4 2 0 ∷ floor 6 0 2 1 ∷ floor 6 2 2 0 ∷ []) false false true 3) (1000 , 2003) (valid (route false 127 8 true ((2003 , 1004) ∷ (1004 , 1006) ∷ (1006 , 2001) ∷ []) (3 ∷ 1 ∷ 3 ∷ []))) - ⊕ extend (link true 3 0 false ([]) (floor 5 4 2 0 ∷ floor 6 0 2 1 ∷ floor 6 2 2 0 ∷ []) false false true 3) (1000 , 2001) (valid (route false 127 8 true ((2001 , 1004) ∷ (1004 , 1006) ∷ (1006 , 2001) ∷ []) (3 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route false 127 11 true ((1000 , 2001) ∷ (2001 , 1004) ∷ (1004 , 1006) ∷ (1006 , 2001) ∷ []) (3 ∷ 3 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 4 127 false (2004 ∷ 2006 ∷ []) (floor 4 5 1 0 ∷ []) true false true 1) (2000 , 2004) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 4 127 false (2004 ∷ 2006 ∷ []) (floor 4 5 1 0 ∷ []) false false true 1) (2000 , 2006) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 127 4 false ((2000 , 2006) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 127 false (1004 ∷ []) (floor 4 0 1 0 ∷ []) false true true 2) (1000 , 2002) (valid (route false 128 1 false ((2002 , 1000) ∷ (1000 , 1003) ∷ (1003 , 2006) ∷ (2006 , 1004) ∷ []) (2 ∷ 2 ∷ 3 ∷ 3 ∷ []))) - ⊕ extend (link true 2 127 false (1004 ∷ []) (floor 4 0 1 0 ∷ []) false true true 2) (1000 , 2006) (valid (route false 128 1 false ((2006 , 1000) ∷ (1000 , 1003) ∷ (1003 , 2006) ∷ (2006 , 1004) ∷ []) (2 ∷ 2 ∷ 3 ∷ 3 ∷ []))) - ≡ invalid +_ : extend (link true 1 0 false (4006 ∷ []) ([]) false false false 1) (2000 , 4001) (valid (route tt false 127 8 false ((4001 , 4003) ∷ (4003 , 2005) ∷ (2005 , 4006) ∷ []) (2 ∷ 3 ∷ 1 ∷ []))) + ⊕ extend (link true 1 0 false (4006 ∷ []) ([]) false false false 1) (2000 , 2006) (valid (route tt false 127 8 false ((2006 , 2108) ∷ (2108 , 4003) ∷ (4003 , 2005) ∷ (2005 , 4006) ∷ []) (2 ∷ 1 ∷ 3 ∷ 1 ∷ []))) + ≡ valid (route tt true 127 9 false ((2000 , 4001) ∷ (4001 , 4003) ∷ (4003 , 2005) ∷ (2005 , 4006) ∷ []) (1 ∷ 2 ∷ 3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 0 true ([]) (floor 6 5 1 0 ∷ []) false true true 3) (1000 , 2003) (valid (route false 122 8 false ((2003 , 1037) ∷ (1037 , 1025) ∷ (1025 , 2036) ∷ (2036 , 2024) ∷ (2024 , 1005) ∷ (1005 , 1009) ∷ (1009 , 1027) ∷ (1027 , 1019) ∷ (1019 , 1029) ∷ (1029 , 2002) ∷ (2002 , 1031) ∷ (1031 , 2016) ∷ (2016 , 2022) ∷ (2022 , 2018) ∷ (2018 , 1011) ∷ (1011 , 1021) ∷ (1021 , 1038) ∷ (1038 , 2023) ∷ (2023 , 1032) ∷ (1032 , 2017) ∷ (2017 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1004) ∷ (1004 , 2040) ∷ (2040 , 1030) ∷ (1030 , 2010) ∷ (2010 , 1007) ∷ (1007 , 2033) ∷ (2033 , 2015) ∷ (2015 , 1039) ∷ (1039 , 2013) ∷ []) (3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ []))) - ⊕ extend (link true 4 0 true ([]) (floor 6 5 1 0 ∷ []) false true true 3) (1000 , 2006) (valid (route false 122 8 false ((2006 , 1037) ∷ (1037 , 1025) ∷ (1025 , 2036) ∷ (2036 , 2024) ∷ (2024 , 1005) ∷ (1005 , 1009) ∷ (1009 , 1027) ∷ (1027 , 1019) ∷ (1019 , 1029) ∷ (1029 , 2002) ∷ (2002 , 1031) ∷ (1031 , 2016) ∷ (2016 , 2022) ∷ (2022 , 2018) ∷ (2018 , 1011) ∷ (1011 , 1021) ∷ (1021 , 1038) ∷ (1038 , 2023) ∷ (2023 , 1032) ∷ (1032 , 2017) ∷ (2017 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1004) ∷ (1004 , 2040) ∷ (2040 , 1030) ∷ (1030 , 2010) ∷ (2010 , 1007) ∷ (1007 , 2033) ∷ (2033 , 2015) ∷ (2015 , 1039) ∷ (1039 , 2013) ∷ []) (3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ []))) - ≡ invalid +_ : extend (link true 2 0 false (4003 ∷ []) (floor 1 0 1 3 ∷ floor 4 4 2 0 ∷ []) true false true 3) (2000 , 4001) (valid (route tt false 255 7 false ((4001 , 4004) ∷ (4004 , 4003) ∷ (4003 , 4006) ∷ (4006 , 2005) ∷ []) (3 ∷ 3 ∷ 1 ∷ 1 ∷ []))) + ⊕ extend (link true 2 0 false (4003 ∷ []) (floor 1 0 1 3 ∷ floor 4 4 2 0 ∷ []) true false true 3) (2000 , 2004) (valid (route tt false 255 7 false ((2004 , 4004) ∷ (4004 , 4003) ∷ (4003 , 4006) ∷ (4006 , 2005) ∷ []) (3 ∷ 3 ∷ 1 ∷ 1 ∷ []))) + ≡ valid (route tt true 255 9 true ((2000 , 4001) ∷ (4001 , 4004) ∷ (4004 , 4003) ∷ (4003 , 4006) ∷ (4006 , 2005) ∷ []) (3 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 128 true (2002 ∷ 2006 ∷ []) (floor 5 3 2 1 ∷ floor 5 4 1 0 ∷ []) false false false 1) (1000 , 2004) (valid (route true 122 2 false ((2004 , 1003) ∷ (1003 , 2005) ∷ []) (2 ∷ 3 ∷ []))) - ⊕ extend (link true 4 128 false (2002 ∷ 2006 ∷ []) (floor 5 3 2 1 ∷ floor 5 4 1 0 ∷ []) true false false 3) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 128 3 false ((1000 , 2004) ∷ (2004 , 1003) ∷ (1003 , 2005) ∷ []) (1 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 1 0 true (4001 ∷ []) (floor 3 5 1 2 ∷ floor 4 1 2 0 ∷ []) false true true 1) (2000 , 4004) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 1 0 true (4001 ∷ []) (floor 3 5 1 2 ∷ floor 4 1 2 0 ∷ []) false true true 1) (2000 , 2003) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 0 1 false ((2000 , 2003) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 1 255 false ([]) (floor 3 3 1 1 ∷ []) false false false 1) (1000 , 1006) (valid (route false 255 10 true ((1006 , 1000) ∷ (1000 , 1005) ∷ []) (3 ∷ 2 ∷ []))) - ⊕ extend (link true 1 128 false ([]) (floor 3 3 1 1 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 6 true ((1002 , 1021) ∷ (1021 , 2029) ∷ (2029 , 2017) ∷ (2017 , 1032) ∷ (1032 , 1039) ∷ (1039 , 1033) ∷ (1033 , 2003) ∷ (2003 , 1038) ∷ (1038 , 2035) ∷ (2035 , 2025) ∷ (2025 , 2034) ∷ (2034 , 2020) ∷ (2020 , 1028) ∷ (1028 , 2031) ∷ (2031 , 2006) ∷ (2006 , 2007) ∷ (2007 , 2016) ∷ (2016 , 2005) ∷ (2005 , 1027) ∷ (1027 , 2040) ∷ (2040 , 2037) ∷ (2037 , 2019) ∷ (2019 , 2008) ∷ (2008 , 1023) ∷ (1023 , 1013) ∷ (1013 , 2010) ∷ (2010 , 2030) ∷ (2030 , 2011) ∷ (2011 , 2004) ∷ (2004 , 1001) ∷ []) (2 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ []))) - ≡ valid (route false 128 7 true ((1000 , 1002) ∷ (1002 , 1021) ∷ (1021 , 2029) ∷ (2029 , 2017) ∷ (2017 , 1032) ∷ (1032 , 1039) ∷ (1039 , 1033) ∷ (1033 , 2003) ∷ (2003 , 1038) ∷ (1038 , 2035) ∷ (2035 , 2025) ∷ (2025 , 2034) ∷ (2034 , 2020) ∷ (2020 , 1028) ∷ (1028 , 2031) ∷ (2031 , 2006) ∷ (2006 , 2007) ∷ (2007 , 2016) ∷ (2016 , 2005) ∷ (2005 , 1027) ∷ (1027 , 2040) ∷ (2040 , 2037) ∷ (2037 , 2019) ∷ (2019 , 2008) ∷ (2008 , 1023) ∷ (1023 , 1013) ∷ (1013 , 2010) ∷ (2010 , 2030) ∷ (2030 , 2011) ∷ (2011 , 2004) ∷ (2004 , 1001) ∷ []) (2 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ [])) +_ : extend (link true 4 0 false ([]) (floor 6 4 2 3 ∷ []) false false true 2) (2000 , 4005) (valid (route tt true 0 5 false ((4005 , 2006) ∷ []) (3 ∷ []))) + ⊕ extend (link true 4 0 false ([]) (floor 6 4 2 3 ∷ []) true false true 2) (2000 , 4003) (valid (route tt true 0 5 false ((4003 , 2006) ∷ []) (3 ∷ []))) + ≡ valid (route tt true 0 9 false ((2000 , 4005) ∷ (4005 , 2006) ∷ []) (2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 127 false (2004 ∷ []) (floor 1 1 1 2 ∷ floor 2 4 2 0 ∷ []) false true true 1) (1000 , 2003) (valid (route true 255 3 false ((2003 , 2006) ∷ (2006 , 2001) ∷ []) (3 ∷ 1 ∷ []))) - ⊕ extend (link true 2 0 false (2004 ∷ []) (floor 1 1 1 2 ∷ floor 2 4 2 0 ∷ []) false false true 1) (1000 , 1005) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 0 2 false ((1000 , 1005) ∷ []) (1 ∷ [])) +_ : extend (link true 1 255 false (2002 ∷ 4002 ∷ []) (floor 1 2 1 3 ∷ floor 2 4 2 0 ∷ floor 3 4 2 1 ∷ []) false true false 1) (2000 , 2003) (valid (route tt false 0 0 true ((2003 , 3003) ∷ []) (0 ∷ []))) + ⊕ extend (link true 1 255 false (2002 ∷ 4002 ∷ []) (floor 1 2 1 3 ∷ floor 2 4 2 0 ∷ floor 3 4 2 1 ∷ []) true true false 1) (2000 , 4003) (valid (route tt false 0 0 true ((4003 , 5003) ∷ []) (0 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 2 122 false (2001 ∷ []) ([]) false false true 2) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 2 122 false (2001 ∷ []) ([]) false false true 2) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 122 2 false ((1000 , 1006) ∷ []) (2 ∷ [])) +_ : extend (link true 1 127 true ([]) ([]) false false true 3) (2000 , 2004) (valid (route tt true 0 3 false ((2004 , 4015) ∷ (4015 , 2038) ∷ (2038 , 2024) ∷ (2024 , 2005) ∷ (2005 , 2023) ∷ (2023 , 4027) ∷ (4027 , 2031) ∷ (2031 , 2014) ∷ (2014 , 4006) ∷ (4006 , 4022) ∷ (4022 , 4018) ∷ (4018 , 2011) ∷ (2011 , 2021) ∷ (2021 , 2033) ∷ (2033 , 2002) ∷ (2002 , 2037) ∷ (2037 , 2017) ∷ (2017 , 4003) ∷ (4003 , 2008) ∷ (2008 , 4009) ∷ (4009 , 4039) ∷ (4039 , 2035) ∷ (2035 , 2040) ∷ (2040 , 4030) ∷ (4030 , 2010) ∷ (2010 , 4032) ∷ (4032 , 2013) ∷ (2013 , 2036) ∷ (2036 , 2016) ∷ (2016 , 2029) ∷ (2029 , 2034) ∷ []) (1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 1 127 true ([]) ([]) true false true 3) (2000 , 4006) (valid (route tt true 0 3 false ((4006 , 4015) ∷ (4015 , 2038) ∷ (2038 , 2024) ∷ (2024 , 2005) ∷ (2005 , 2023) ∷ (2023 , 4027) ∷ (4027 , 2031) ∷ (2031 , 2014) ∷ (2014 , 4006) ∷ (4006 , 4022) ∷ (4022 , 4018) ∷ (4018 , 2011) ∷ (2011 , 2021) ∷ (2021 , 2033) ∷ (2033 , 2002) ∷ (2002 , 2037) ∷ (2037 , 2017) ∷ (2017 , 4003) ∷ (4003 , 2008) ∷ (2008 , 4009) ∷ (4009 , 4039) ∷ (4039 , 2035) ∷ (2035 , 2040) ∷ (2040 , 4030) ∷ (4030 , 2010) ∷ (2010 , 4032) ∷ (4032 , 2013) ∷ (2013 , 2036) ∷ (2036 , 2016) ∷ (2016 , 2029) ∷ (2029 , 2034) ∷ []) (1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 3 0 false (1005 ∷ 2006 ∷ []) (floor 2 6 2 1 ∷ []) false false true 2) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 3 0 false (1005 ∷ 2006 ∷ []) (floor 2 6 2 1 ∷ []) false false true 2) (1000 , 1004) (valid (route false 128 6 false ((1004 , 1005) ∷ []) (2 ∷ []))) - ≡ valid (route false 0 3 false ((1000 , 2001) ∷ []) (2 ∷ [])) +_ : extend (link true 1 122 false ([]) (floor 1 6 1 2 ∷ floor 3 2 1 2 ∷ floor 5 6 2 0 ∷ []) false false true 2) (2000 , 2003) (valid (route tt false 127 4 true ((2003 , 4006) ∷ (4006 , 2004) ∷ []) (3 ∷ 3 ∷ []))) + ⊕ extend (link true 1 127 true ([]) (floor 1 6 1 2 ∷ floor 3 2 1 2 ∷ floor 5 6 2 0 ∷ []) false false false 2) (2000 , 4006) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 127 5 true ((2000 , 2003) ∷ (2003 , 4006) ∷ (4006 , 2004) ∷ []) (2 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 2 0 false ([]) (floor 0 6 2 3 ∷ floor 2 2 1 0 ∷ []) false false false 1) (1000 , 2002) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 2 0 false ([]) (floor 0 6 2 3 ∷ floor 2 2 1 0 ∷ []) false false false 1) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) - ≡ invalid +_ : extend (link true 1 255 true (4003 ∷ []) (floor 3 4 2 2 ∷ floor 3 6 1 0 ∷ floor 4 5 2 3 ∷ []) true false true 2) (2000 , 2006) (valid (route tt false 0 1 true ((2006 , 2003) ∷ (2003 , 4005) ∷ (4005 , 5005) ∷ []) (3 ∷ 1 ∷ 0 ∷ []))) + ⊕ extend (link true 1 255 true (4003 ∷ []) (floor 3 4 2 2 ∷ floor 3 6 1 0 ∷ floor 4 5 2 3 ∷ []) true false true 2) (2000 , 2005) (valid (route tt false 0 1 true ((2005 , 2003) ∷ (2003 , 4005) ∷ (4005 , 5005) ∷ []) (3 ∷ 1 ∷ 0 ∷ []))) + ≡ valid (route tt true 255 2 true ((2000 , 2005) ∷ (2005 , 2003) ∷ (2003 , 4005) ∷ (4005 , 5005) ∷ []) (2 ∷ 3 ∷ 1 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 2 128 true ([]) ([]) false false true 3) (1000 , 1005) (valid (route true 0 6 false ((1005 , 2004) ∷ (2004 , 2001) ∷ (2001 , 2003) ∷ []) (3 ∷ 1 ∷ 1 ∷ []))) - ⊕ extend (link true 2 128 true ([]) ([]) false false true 3) (1000 , 1001) (valid (route true 0 6 false ((1001 , 2004) ∷ (2004 , 2001) ∷ (2001 , 2003) ∷ []) (3 ∷ 1 ∷ 1 ∷ []))) - ≡ valid (route true 128 8 false ((1000 , 1001) ∷ (1001 , 2004) ∷ (2004 , 2001) ∷ (2001 , 2003) ∷ []) (3 ∷ 3 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 3 127 false ([]) (floor 4 3 2 3 ∷ floor 5 5 1 2 ∷ floor 6 1 1 0 ∷ []) false true false 2) (2000 , 2003) (valid (route tt false 0 7 true ((2003 , 2002) ∷ (2002 , 4004) ∷ (4004 , 2001) ∷ []) (3 ∷ 1 ∷ 2 ∷ []))) + ⊕ extend (link true 3 127 false ([]) (floor 4 3 2 3 ∷ floor 5 5 1 2 ∷ floor 6 1 1 0 ∷ []) true true false 2) (2000 , 4001) (valid (route tt false 0 7 true ((4001 , 2002) ∷ (2002 , 4004) ∷ (4004 , 2001) ∷ []) (3 ∷ 1 ∷ 2 ∷ []))) + ≡ invalid _ = refl -_ : extend (link true 2 255 false (1004 ∷ []) (floor 3 3 2 2 ∷ floor 4 0 1 1 ∷ floor 4 4 1 3 ∷ []) false false true 3) (1000 , 2003) (valid (route false 255 9 false ((2003 , 1005) ∷ (1005 , 1003) ∷ (1003 , 1002) ∷ (1002 , 1006) ∷ []) (3 ∷ 2 ∷ 3 ∷ 1 ∷ []))) - ⊕ extend (link true 3 122 false (1004 ∷ []) (floor 3 3 2 2 ∷ floor 4 0 1 1 ∷ floor 4 4 1 3 ∷ []) false false true 2) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 122 3 false ((1000 , 1006) ∷ []) (2 ∷ [])) +_ : extend (link true 4 122 false (4001 ∷ []) (floor 6 5 1 1 ∷ []) false true true 2) (2000 , 2004) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 4 122 false (4001 ∷ []) (floor 6 5 1 1 ∷ []) false true true 2) (2000 , 4004) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 122 4 false ((2000 , 2004) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 2 255 false ([]) (floor 1 4 1 2 ∷ floor 2 5 1 1 ∷ floor 6 5 1 1 ∷ []) true false true 2) (1000 , 1006) (valid (route false 128 6 false ((1006 , 1002) ∷ (1002 , 2006) ∷ []) (2 ∷ 3 ∷ []))) - ⊕ extend (link true 4 0 true ([]) (floor 1 4 1 2 ∷ floor 2 5 1 1 ∷ floor 6 5 1 1 ∷ []) true false true 2) (1000 , 1003) (valid (route false 127 0 true ((1003 , 2006) ∷ (2006 , 2001) ∷ (2001 , 1002) ∷ []) (2 ∷ 3 ∷ 2 ∷ []))) - ≡ valid (route false 255 8 true ((1000 , 1006) ∷ (1006 , 1002) ∷ (1002 , 2006) ∷ []) (2 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 1 127 false ([]) (floor 1 5 1 2 ∷ floor 3 5 2 0 ∷ floor 4 4 1 2 ∷ []) false false false 2) (2000 , 4001) (valid (route tt false 127 11 true ((4001 , 2018) ∷ (2018 , 4003) ∷ (4003 , 4031) ∷ (4031 , 2012) ∷ (2012 , 4002) ∷ (4002 , 4038) ∷ (4038 , 2034) ∷ (2034 , 2007) ∷ (2007 , 2006) ∷ (2006 , 4015) ∷ (4015 , 2011) ∷ (2011 , 4039) ∷ (4039 , 2022) ∷ (2022 , 4019) ∷ (4019 , 4008) ∷ (4008 , 2017) ∷ (2017 , 4005) ∷ (4005 , 2032) ∷ (2032 , 2035) ∷ (2035 , 2030) ∷ (2030 , 4021) ∷ (4021 , 4014) ∷ (4014 , 2023) ∷ (2023 , 2029) ∷ (2029 , 4027) ∷ (4027 , 2016) ∷ (2016 , 4033) ∷ (4033 , 2020) ∷ (2020 , 4037) ∷ []) (2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 1 127 false ([]) (floor 1 5 1 2 ∷ floor 3 5 2 0 ∷ floor 4 4 1 2 ∷ []) false false false 2) (2000 , 4002) (valid (route tt false 127 11 true ((4002 , 2018) ∷ (2018 , 4003) ∷ (4003 , 4031) ∷ (4031 , 2012) ∷ (2012 , 4002) ∷ (4002 , 4038) ∷ (4038 , 2034) ∷ (2034 , 2007) ∷ (2007 , 2006) ∷ (2006 , 4015) ∷ (4015 , 2011) ∷ (2011 , 4039) ∷ (4039 , 2022) ∷ (2022 , 4019) ∷ (4019 , 4008) ∷ (4008 , 2017) ∷ (2017 , 4005) ∷ (4005 , 2032) ∷ (2032 , 2035) ∷ (2035 , 2030) ∷ (2030 , 4021) ∷ (4021 , 4014) ∷ (4014 , 2023) ∷ (2023 , 2029) ∷ (2029 , 4027) ∷ (4027 , 2016) ∷ (2016 , 4033) ∷ (4033 , 2020) ∷ (2020 , 4037) ∷ []) (2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ []))) + ≡ valid (route tt false 127 12 true ((2000 , 4001) ∷ (4001 , 2018) ∷ (2018 , 4003) ∷ (4003 , 4031) ∷ (4031 , 2012) ∷ (2012 , 4002) ∷ (4002 , 4038) ∷ (4038 , 2034) ∷ (2034 , 2007) ∷ (2007 , 2006) ∷ (2006 , 4015) ∷ (4015 , 2011) ∷ (2011 , 4039) ∷ (4039 , 2022) ∷ (2022 , 4019) ∷ (4019 , 4008) ∷ (4008 , 2017) ∷ (2017 , 4005) ∷ (4005 , 2032) ∷ (2032 , 2035) ∷ (2035 , 2030) ∷ (2030 , 4021) ∷ (4021 , 4014) ∷ (4014 , 2023) ∷ (2023 , 2029) ∷ (2029 , 4027) ∷ (4027 , 2016) ∷ (2016 , 4033) ∷ (4033 , 2020) ∷ (2020 , 4037) ∷ []) (2 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 255 false (1002 ∷ []) (floor 2 1 1 3 ∷ floor 4 0 2 1 ∷ []) true false true 1) (1000 , 1005) (valid (route true 0 0 true ((1005 , 1001) ∷ []) (3 ∷ []))) - ⊕ extend (link true 4 0 false (1002 ∷ []) (floor 2 1 1 3 ∷ floor 4 0 2 1 ∷ []) false false true 3) (1000 , 2006) (valid (route false 122 5 false ((2006 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1002) ∷ []) (2 ∷ 1 ∷ 1 ∷ []))) - ≡ valid (route true 122 9 false ((1000 , 2006) ∷ (2006 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1002) ∷ []) (3 ∷ 2 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 1 127 false (2001 ∷ []) (floor 2 5 1 1 ∷ floor 3 3 1 0 ∷ floor 4 0 2 1 ∷ []) true false true 1) (2000 , 2003) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 1 127 false (2001 ∷ []) (floor 2 5 1 1 ∷ floor 3 3 1 0 ∷ floor 4 0 2 1 ∷ []) true false true 1) (2000 , 2005) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 127 1 true ((2000 , 2003) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 0 false (1001 ∷ 2005 ∷ []) ([]) false false true 1) (1000 , 1004) (valid (route false 127 11 false ((1004 , 1002) ∷ (1002 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1005) ∷ []) (2 ∷ 3 ∷ 2 ∷ 3 ∷ []))) - ⊕ extend (link true 4 128 false (1001 ∷ 2005 ∷ []) ([]) false false true 3) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 127 13 false ((1000 , 1004) ∷ (1004 , 1002) ∷ (1002 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1005) ∷ []) (1 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 1 127 false (2002 ∷ 2003 ∷ []) (floor 1 4 2 2 ∷ floor 1 6 2 1 ∷ floor 3 4 2 2 ∷ []) false false true 1) (2000 , 2006) (valid (route tt false 0 0 true ((2006 , 3006) ∷ []) (0 ∷ []))) + ⊕ extend (link true 4 122 false (2002 ∷ 2003 ∷ []) (floor 1 4 2 2 ∷ floor 1 6 2 1 ∷ floor 3 4 2 2 ∷ []) false false false 3) (2000 , 4006) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt false 127 1 true ((2000 , 2006) ∷ (2006 , 3006) ∷ []) (1 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 3 255 false ([]) ([]) true false true 3) (1000 , 2004) (valid (route false 128 10 false ((2004 , 2001) ∷ (2001 , 1005) ∷ []) (2 ∷ 1 ∷ []))) - ⊕ extend (link true 4 127 false ([]) ([]) false true true 3) (1000 , 2005) (valid (route false 127 5 false ((2005 , 1002) ∷ (1002 , 1006) ∷ (1006 , 1005) ∷ []) (2 ∷ 2 ∷ 3 ∷ []))) - ≡ valid (route false 127 9 false ((1000 , 2005) ∷ (2005 , 1002) ∷ (1002 , 1006) ∷ (1006 , 1005) ∷ []) (3 ∷ 2 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 1 127 false (2004 ∷ 4005 ∷ []) ([]) false false true 1) (2000 , 4003) (valid (route tt true 127 11 false ((4003 , 2005) ∷ (2005 , 4002) ∷ (4002 , 2000) ∷ (2000 , 2004) ∷ []) (1 ∷ 1 ∷ 3 ∷ 2 ∷ []))) + ⊕ extend (link true 4 127 true (2004 ∷ 4005 ∷ []) ([]) true false true 3) (2000 , 2005) (valid (route tt false 122 3 false ((2005 , 2003) ∷ (2003 , 2006) ∷ (2006 , 4004) ∷ []) (3 ∷ 1 ∷ 1 ∷ []))) + ≡ valid (route tt true 127 7 true ((2000 , 2005) ∷ (2005 , 2003) ∷ (2003 , 2006) ∷ (2006 , 4004) ∷ []) (3 ∷ 3 ∷ 1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 122 true (1003 ∷ 2003 ∷ []) (floor 0 3 2 2 ∷ floor 2 2 1 0 ∷ floor 5 3 1 3 ∷ []) true false false 3) (1000 , 1005) (valid (route false 0 9 false ((1005 , 2002) ∷ (2002 , 1004) ∷ (1004 , 2003) ∷ []) (3 ∷ 3 ∷ 1 ∷ []))) - ⊕ extend (link true 4 0 true (1003 ∷ 2003 ∷ []) (floor 0 3 2 2 ∷ floor 2 2 1 0 ∷ floor 5 3 1 3 ∷ []) false true false 3) (1000 , 2006) (valid (route false 255 9 false ((2006 , 2004) ∷ (2004 , 2002) ∷ (2002 , 2003) ∷ []) (2 ∷ 3 ∷ 3 ∷ []))) - ≡ valid (route true 122 10 true ((1000 , 1005) ∷ (1005 , 2002) ∷ (2002 , 1004) ∷ (1004 , 2003) ∷ []) (3 ∷ 3 ∷ 3 ∷ 1 ∷ [])) +_ : extend (link true 1 255 false (4003 ∷ []) (floor 1 0 2 3 ∷ floor 4 0 1 0 ∷ []) true false true 2) (2000 , 4004) (valid (route tt false 255 7 false ((4004 , 2011) ∷ (2011 , 2008) ∷ (2008 , 4020) ∷ (4020 , 2010) ∷ (2010 , 2013) ∷ (2013 , 2021) ∷ (2021 , 4033) ∷ (4033 , 2028) ∷ (2028 , 2019) ∷ (2019 , 2014) ∷ (2014 , 4002) ∷ (4002 , 4012) ∷ (4012 , 2039) ∷ (2039 , 2001) ∷ (2001 , 2040) ∷ (2040 , 2015) ∷ (2015 , 2025) ∷ (2025 , 2038) ∷ (2038 , 2003) ∷ (2003 , 4034) ∷ (4034 , 4031) ∷ (4031 , 4017) ∷ (4017 , 2036) ∷ (2036 , 2035) ∷ (2035 , 2030) ∷ (2030 , 4022) ∷ (4022 , 2037) ∷ (2037 , 4032) ∷ (4032 , 2023) ∷ []) (3 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ []))) + ⊕ extend (link true 1 255 false (4003 ∷ []) (floor 1 0 2 3 ∷ floor 4 0 1 0 ∷ []) false false true 2) (2000 , 2001) (valid (route tt false 255 7 false ((2001 , 2011) ∷ (2011 , 2008) ∷ (2008 , 4020) ∷ (4020 , 2010) ∷ (2010 , 2013) ∷ (2013 , 2021) ∷ (2021 , 4033) ∷ (4033 , 2028) ∷ (2028 , 2019) ∷ (2019 , 2014) ∷ (2014 , 4002) ∷ (4002 , 4012) ∷ (4012 , 2039) ∷ (2039 , 2001) ∷ (2001 , 2040) ∷ (2040 , 2015) ∷ (2015 , 2025) ∷ (2025 , 2038) ∷ (2038 , 2003) ∷ (2003 , 4034) ∷ (4034 , 4031) ∷ (4031 , 4017) ∷ (4017 , 2036) ∷ (2036 , 2035) ∷ (2035 , 2030) ∷ (2030 , 4022) ∷ (4022 , 2037) ∷ (2037 , 4032) ∷ (4032 , 2023) ∷ []) (3 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route tt false 255 8 false ((2000 , 2001) ∷ (2001 , 2011) ∷ (2011 , 2008) ∷ (2008 , 4020) ∷ (4020 , 2010) ∷ (2010 , 2013) ∷ (2013 , 2021) ∷ (2021 , 4033) ∷ (4033 , 2028) ∷ (2028 , 2019) ∷ (2019 , 2014) ∷ (2014 , 4002) ∷ (4002 , 4012) ∷ (4012 , 2039) ∷ (2039 , 2001) ∷ (2001 , 2040) ∷ (2040 , 2015) ∷ (2015 , 2025) ∷ (2025 , 2038) ∷ (2038 , 2003) ∷ (2003 , 4034) ∷ (4034 , 4031) ∷ (4031 , 4017) ∷ (4017 , 2036) ∷ (2036 , 2035) ∷ (2035 , 2030) ∷ (2030 , 4022) ∷ (4022 , 2037) ∷ (2037 , 4032) ∷ (4032 , 2023) ∷ []) (2 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 2 0 true ([]) (floor 0 1 2 2 ∷ []) true true true 2) (1000 , 1001) (valid (route false 128 8 true ((1001 , 1006) ∷ (1006 , 2002) ∷ []) (2 ∷ 1 ∷ []))) - ⊕ extend (link true 2 0 true ([]) (floor 0 1 2 2 ∷ []) true true true 2) (1000 , 2004) (valid (route false 128 8 true ((2004 , 1006) ∷ (1006 , 2002) ∷ []) (2 ∷ 1 ∷ []))) +_ : extend (link true 2 127 false (4001 ∷ 2006 ∷ []) (floor 6 6 1 3 ∷ []) false true true 2) (2000 , 4005) (valid (route tt false 122 5 true ((4005 , 2027) ∷ (2027 , 4025) ∷ (4025 , 2016) ∷ (2016 , 4034) ∷ (4034 , 4012) ∷ (4012 , 4031) ∷ (4031 , 2036) ∷ (2036 , 2004) ∷ (2004 , 4029) ∷ (4029 , 4002) ∷ (4002 , 4038) ∷ (4038 , 4030) ∷ (4030 , 2013) ∷ (2013 , 4026) ∷ (4026 , 2019) ∷ (2019 , 2024) ∷ (2024 , 2014) ∷ (2014 , 4032) ∷ (4032 , 2015) ∷ (2015 , 2028) ∷ (2028 , 2003) ∷ (2003 , 4007) ∷ (4007 , 4037) ∷ (4037 , 2008) ∷ (2008 , 4001) ∷ (4001 , 2017) ∷ (2017 , 2006) ∷ (2006 , 4018) ∷ (4018 , 4022) ∷ []) (3 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ []))) + ⊕ extend (link true 2 127 false (4001 ∷ 2006 ∷ []) (floor 6 6 1 3 ∷ []) false true true 2) (2000 , 4002) (valid (route tt false 122 5 true ((4002 , 2027) ∷ (2027 , 4025) ∷ (4025 , 2016) ∷ (2016 , 4034) ∷ (4034 , 4012) ∷ (4012 , 4031) ∷ (4031 , 2036) ∷ (2036 , 2004) ∷ (2004 , 4029) ∷ (4029 , 4002) ∷ (4002 , 4038) ∷ (4038 , 4030) ∷ (4030 , 2013) ∷ (2013 , 4026) ∷ (4026 , 2019) ∷ (2019 , 2024) ∷ (2024 , 2014) ∷ (2014 , 4032) ∷ (4032 , 2015) ∷ (2015 , 2028) ∷ (2028 , 2003) ∷ (2003 , 4007) ∷ (4007 , 4037) ∷ (4037 , 2008) ∷ (2008 , 4001) ∷ (4001 , 2017) ∷ (2017 , 2006) ∷ (2006 , 4018) ∷ (4018 , 4022) ∷ []) (3 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 122 true ([]) (floor 1 3 2 1 ∷ floor 3 0 1 0 ∷ []) true true true 1) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 3 0 false ([]) (floor 1 3 2 1 ∷ floor 3 0 1 0 ∷ []) true false true 3) (1000 , 1003) (valid (route false 122 8 false ((1003 , 1000) ∷ (1000 , 2004) ∷ []) (1 ∷ 3 ∷ []))) - ≡ valid (route true 122 1 true ((1000 , 1006) ∷ []) (1 ∷ [])) +_ : extend (link true 3 127 false ([]) ([]) false true true 2) (2000 , 2005) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 2 122 false ([]) ([]) true true true 3) (2000 , 4006) (valid (route tt false 0 0 true ((4006 , 5006) ∷ []) (0 ∷ []))) + ≡ valid (route tt false 127 3 false ((2000 , 2005) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 1 127 true (1003 ∷ 2002 ∷ []) ([]) false false true 3) (1000 , 1004) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 4 122 true (1003 ∷ 2002 ∷ []) ([]) false true false 3) (1000 , 2003) (valid (route false 122 6 false ((2003 , 2002) ∷ (2002 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (2 ∷ 2 ∷ 1 ∷ 1 ∷ []))) - ≡ valid (route true 122 10 false ((1000 , 2003) ∷ (2003 , 2002) ∷ (2002 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (3 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 2 255 false ([]) ([]) true false false 3) (2000 , 2004) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 2 127 false ([]) ([]) false false true 1) (2000 , 2006) (valid (route tt false 122 5 false ((2006 , 4005) ∷ (4005 , 4002) ∷ []) (3 ∷ 1 ∷ []))) + ≡ valid (route tt false 127 7 false ((2000 , 2006) ∷ (2006 , 4005) ∷ (4005 , 4002) ∷ []) (1 ∷ 3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 3 255 false (1002 ∷ []) (floor 4 0 2 3 ∷ floor 5 2 1 3 ∷ []) true false true 1) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) - ⊕ extend (link true 3 0 true (1002 ∷ []) (floor 4 0 2 3 ∷ floor 5 2 1 3 ∷ []) true true true 1) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route true 0 3 true ((1000 , 2006) ∷ []) (1 ∷ [])) +_ : extend (link true 1 255 true (4002 ∷ []) (floor 1 2 2 0 ∷ floor 2 0 1 2 ∷ floor 5 6 2 0 ∷ []) true true true 2) (2000 , 2002) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 1 255 true (4002 ∷ []) (floor 1 2 2 0 ∷ floor 2 0 1 2 ∷ floor 5 6 2 0 ∷ []) false true true 2) (2000 , 4006) (valid (route tt false 0 0 false ([]) ([]))) + ≡ valid (route tt true 255 1 false ((2000 , 4006) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 2 122 false ([]) (floor 3 0 1 1 ∷ floor 4 6 2 2 ∷ floor 5 4 2 0 ∷ []) false false true 1) (1000 , 1002) (valid (route false 128 11 false ((1002 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2001) ∷ []) (1 ∷ 2 ∷ 3 ∷ []))) - ⊕ extend (link true 4 255 true ([]) (floor 3 0 1 1 ∷ floor 4 6 2 2 ∷ floor 5 4 2 0 ∷ []) false false false 1) (1000 , 2001) (valid (route true 127 0 false ((2001 , 1006) ∷ (1006 , 1002) ∷ (1002 , 2004) ∷ (2004 , 2003) ∷ []) (3 ∷ 1 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route false 128 13 false ((1000 , 1002) ∷ (1002 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2001) ∷ []) (1 ∷ 1 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 1 122 false (2003 ∷ 2006 ∷ []) (floor 6 6 1 3 ∷ []) false false true 1) (2000 , 2006) (valid (route tt false 0 0 true ((2006 , 3006) ∷ []) (0 ∷ []))) + ⊕ extend (link true 1 122 false (2003 ∷ 2006 ∷ []) (floor 6 6 1 3 ∷ []) false false true 1) (2000 , 4004) (valid (route tt false 0 0 true ((4004 , 5004) ∷ []) (0 ∷ []))) + ≡ valid (route tt false 122 1 true ((2000 , 4004) ∷ (4004 , 5004) ∷ []) (1 ∷ 0 ∷ [])) _ = refl -_ : extend (link true 1 255 false ([]) (floor 2 4 1 3 ∷ floor 5 6 2 3 ∷ []) false false true 3) (1000 , 1006) (valid (route false 255 1 false ((1006 , 2006) ∷ (2006 , 2003) ∷ []) (1 ∷ 1 ∷ []))) - ⊕ extend (link true 1 255 false ([]) (floor 2 4 1 3 ∷ floor 5 6 2 3 ∷ []) false false true 3) (1000 , 1005) (valid (route false 255 1 false ((1005 , 2006) ∷ (2006 , 2003) ∷ []) (1 ∷ 1 ∷ []))) - ≡ valid (route false 255 2 false ((1000 , 1006) ∷ (1006 , 2006) ∷ (2006 , 2003) ∷ []) (3 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 1 127 true ([]) (floor 2 5 1 2 ∷ floor 3 2 2 3 ∷ []) false true false 3) (2000 , 4003) (valid (route tt false 0 0 false ([]) ([]))) + ⊕ extend (link true 1 127 true ([]) (floor 2 5 1 2 ∷ floor 3 2 2 3 ∷ []) true true false 3) (2000 , 4001) (valid (route tt false 0 0 false ([]) ([]))) + ≡ invalid _ = refl -_ : extend (link true 1 255 true (1006 ∷ 2002 ∷ []) ([]) false true true 2) (1000 , 1004) (valid (route false 122 8 false ((1004 , 2004) ∷ (2004 , 1002) ∷ []) (2 ∷ 1 ∷ []))) - ⊕ extend (link true 2 122 false (1006 ∷ 2002 ∷ []) ([]) true true true 3) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) - ≡ valid (route false 122 2 true ((1000 , 1002) ∷ []) (3 ∷ [])) +_ : extend (link true 2 127 false ([]) (floor 2 2 2 2 ∷ floor 5 1 1 1 ∷ []) false true false 2) (2000 , 2006) (valid (route tt true 0 0 false ((2006 , 4004) ∷ (4004 , 2011) ∷ (2011 , 2003) ∷ (2003 , 4002) ∷ (4002 , 4014) ∷ (4014 , 4022) ∷ (4022 , 2037) ∷ (2037 , 2018) ∷ (2018 , 2028) ∷ (2028 , 4007) ∷ (4007 , 4021) ∷ (4021 , 4032) ∷ (4032 , 2016) ∷ (2016 , 4026) ∷ (4026 , 2015) ∷ (2015 , 2031) ∷ (2031 , 2024) ∷ (2024 , 4008) ∷ (4008 , 2012) ∷ (2012 , 4017) ∷ (4017 , 2039) ∷ (2039 , 4009) ∷ (4009 , 4005) ∷ (4005 , 2023) ∷ (2023 , 4029) ∷ (4029 , 2033) ∷ (2033 , 4025) ∷ (4025 , 4040) ∷ (4040 , 4027) ∷ (4027 , 4020) ∷ (4020 , 2019) ∷ []) (1 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ []))) + ⊕ extend (link true 2 127 false ([]) (floor 2 2 2 2 ∷ floor 5 1 1 1 ∷ []) false true false 2) (2000 , 4005) (valid (route tt true 0 0 false ((4005 , 4004) ∷ (4004 , 2011) ∷ (2011 , 2003) ∷ (2003 , 4002) ∷ (4002 , 4014) ∷ (4014 , 4022) ∷ (4022 , 2037) ∷ (2037 , 2018) ∷ (2018 , 2028) ∷ (2028 , 4007) ∷ (4007 , 4021) ∷ (4021 , 4032) ∷ (4032 , 2016) ∷ (2016 , 4026) ∷ (4026 , 2015) ∷ (2015 , 2031) ∷ (2031 , 2024) ∷ (2024 , 4008) ∷ (4008 , 2012) ∷ (2012 , 4017) ∷ (4017 , 2039) ∷ (2039 , 4009) ∷ (4009 , 4005) ∷ (4005 , 2023) ∷ (2023 , 4029) ∷ (4029 , 2033) ∷ (2033 , 4025) ∷ (4025 , 4040) ∷ (4040 , 4027) ∷ (4027 , 4020) ∷ (4020 , 2019) ∷ []) (1 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ []))) + ≡ invalid _ = refl