diff --git a/tests/core/pyspec/eth2spec/gen_helpers/gen_base/gen_runner.py b/tests/core/pyspec/eth2spec/gen_helpers/gen_base/gen_runner.py index 3ab2e9eea8..e7fdd48fb8 100644 --- a/tests/core/pyspec/eth2spec/gen_helpers/gen_base/gen_runner.py +++ b/tests/core/pyspec/eth2spec/gen_helpers/gen_base/gen_runner.py @@ -140,17 +140,7 @@ def should_skip_case_dir(case_dir, is_force, diagnostics_obj): return is_skip, diagnostics_obj -def run_generator(generator_name, test_providers: Iterable[TestProvider]): - """ - Implementation for a general test generator. - :param generator_name: The name of the generator. (lowercase snake_case) - :param test_providers: A list of test provider, - each of these returns a callable that returns an iterable of test cases. - The call to get the iterable may set global configuration, - and the iterable should not be resumed after a pause with a change of that configuration. - :return: - """ - +def create_arg_parser(generator_name: str) -> argparse.ArgumentParser: parser = argparse.ArgumentParser( prog="gen-" + generator_name, description=f"Generate YAML test suite files for {generator_name}", @@ -194,6 +184,23 @@ def run_generator(generator_name, test_providers: Iterable[TestProvider]): help="if set only print tests to generate, do not actually run the test and dump the target data", ) + return parser + + +def run_generator(generator_name, test_providers: Iterable[TestProvider], parser: argparse.ArgumentParser = None): + """ + Implementation for a general test generator. + :param generator_name: The name of the generator. (lowercase snake_case) + :param test_providers: A list of test provider, + each of these returns a callable that returns an iterable of test cases. + The call to get the iterable may set global configuration, + and the iterable should not be resumed after a pause with a change of that configuration. + :return: + """ + + if parser is None: + parser = create_arg_parser(generator_name) + args = parser.parse_args() output_dir = args.output_dir if not args.force: diff --git a/tests/core/pyspec/eth2spec/test/helpers/fork_choice.py b/tests/core/pyspec/eth2spec/test/helpers/fork_choice.py index 094e2e8a5c..503a8fd88f 100644 --- a/tests/core/pyspec/eth2spec/test/helpers/fork_choice.py +++ b/tests/core/pyspec/eth2spec/test/helpers/fork_choice.py @@ -80,10 +80,13 @@ def run_func(): yield from with_blob_data(spec, blob_data, run_func) -def add_attestation(spec, store, attestation, test_steps, is_from_block=False): - spec.on_attestation(store, attestation, is_from_block=is_from_block) +def add_attestation(spec, store, attestation, test_steps, is_from_block=False, valid=True): + run_on_attestation(spec, store, attestation, is_from_block=is_from_block, valid=valid) yield get_attestation_file_name(attestation), attestation - test_steps.append({'attestation': get_attestation_file_name(attestation)}) + if valid: + test_steps.append({'attestation': get_attestation_file_name(attestation)}) + else: + test_steps.append({'attestation': get_attestation_file_name(attestation), 'valid': False}) def add_attestations(spec, store, attestations, test_steps, is_from_block=False): @@ -282,22 +285,36 @@ def output_head_check(spec, store, test_steps): }) -def output_store_checks(spec, store, test_steps): - test_steps.append({ - 'checks': { - 'time': int(store.time), - 'head': get_formatted_head_output(spec, store), - 'justified_checkpoint': { - 'epoch': int(store.justified_checkpoint.epoch), - 'root': encode_hex(store.justified_checkpoint.root), - }, - 'finalized_checkpoint': { - 'epoch': int(store.finalized_checkpoint.epoch), - 'root': encode_hex(store.finalized_checkpoint.root), - }, - 'proposer_boost_root': encode_hex(store.proposer_boost_root), - } - }) +def output_store_checks(spec, store, test_steps, with_viable_for_head_weights=False): + checks = { + 'time': int(store.time), + 'head': get_formatted_head_output(spec, store), + 'justified_checkpoint': { + 'epoch': int(store.justified_checkpoint.epoch), + 'root': encode_hex(store.justified_checkpoint.root), + }, + 'finalized_checkpoint': { + 'epoch': int(store.finalized_checkpoint.epoch), + 'root': encode_hex(store.finalized_checkpoint.root), + }, + 'proposer_boost_root': encode_hex(store.proposer_boost_root), + } + + if with_viable_for_head_weights: + filtered_block_roots = spec.get_filtered_block_tree(store).keys() + leaves_viable_for_head = [root for root in filtered_block_roots + if not any(c for c in filtered_block_roots if store.blocks[c].parent_root == root)] + + viable_for_head_roots_and_weights = [ + { + 'root': encode_hex(viable_for_head_root), + 'weight': int(spec.get_weight(store, viable_for_head_root)) + } + for viable_for_head_root in leaves_viable_for_head + ] + checks['viable_for_head_roots_and_weights'] = viable_for_head_roots_and_weights + + test_steps.append({'checks': checks}) def apply_next_epoch_with_attestations(spec, diff --git a/tests/core/pyspec/eth2spec/test/phase0/fork_choice/test_sm_links_tree_model.py b/tests/core/pyspec/eth2spec/test/phase0/fork_choice/test_sm_links_tree_model.py new file mode 100644 index 0000000000..1b8623e16e --- /dev/null +++ b/tests/core/pyspec/eth2spec/test/phase0/fork_choice/test_sm_links_tree_model.py @@ -0,0 +1,1166 @@ +import random +from pathlib import Path +from minizinc import ( + Instance, + Model, + Solver, +) +from eth2spec.test.context import ( + spec_state_test, + with_altair_and_later, + with_presets, +) +from eth2spec.test.helpers.constants import ( + MINIMAL, +) +from eth2spec.test.helpers.attestations import ( + next_epoch_with_attestations, + next_slots_with_attestations, + state_transition_with_full_block, + get_valid_attestation_at_slot, + get_valid_attestation, +) +from eth2spec.test.helpers.attester_slashings import ( + get_valid_attester_slashing_by_indices, +) +from eth2spec.test.helpers.fork_choice import ( + get_genesis_forkchoice_store_and_block, + on_tick_and_append_step, + tick_and_add_block, + add_attestation, + add_attester_slashing, + add_block, + output_store_checks, +) +from eth2spec.test.helpers.state import ( + state_transition_and_sign_block, + transition_to, + next_slot, + next_epoch, +) +from eth2spec.test.helpers.block import ( + build_empty_block_for_next_slot, + build_empty_block, + sign_block, +) + +MAX_JUSTIFICATION_RATE = 99 +MIN_JUSTIFICATION_RATE = 91 + +MAX_UNDERJUSTIFICATION_RATE = 65 +MIN_UNDERJUSTIFICATION_RATE = 55 + +EMPTY_SLOTS_RATE = 3 +MAX_TIPS_TO_ATTEST = 2 + +OFF_CHAIN_ATTESTATION_RATE = 10 +ON_CHAIN_ATTESTATION_RATE = 20 + +MAX_ATTESTER_SLASHINGS = 8 +ATTESTER_SLASHINGS_RATE = 8 +OFF_CHAIN_SLASHING_RATE = 33 +ON_CHAIN_SLASHING_RATE = 33 + +INVALID_MESSAGES_RATE = 5 + +class SmLink(tuple): + @property + def source(self): + return self[0] + + @property + def target(self): + return self[1] + + +class BranchTip: + def __init__(self, beacon_state, attestations, participants, eventually_justified_checkpoint): + self.beacon_state = beacon_state + self.attestations = attestations + self.participants = participants + self.eventually_justified_checkpoint = eventually_justified_checkpoint + + def copy(self): + return BranchTip(self.beacon_state.copy(), + self.attestations.copy(), + self.participants.copy(), + self.eventually_justified_checkpoint) + + +class ProtocolMessage: + def __init__(self, payload, valid=True): + self.payload = payload + self.valid = valid + + +def _justifying_participation_rate(rnd: random.Random): + """ + Should be high enough to ensure justification happens + """ + return rnd.randint(MIN_JUSTIFICATION_RATE, MAX_JUSTIFICATION_RATE) + + +def _under_justifying_participation_rate(rnd: random.Random): + return rnd.randint(MIN_UNDERJUSTIFICATION_RATE, MAX_UNDERJUSTIFICATION_RATE) + + +def _create_new_branch_tip(spec, branch_tips: dict[SmLink:BranchTip], sm_link: SmLink) -> BranchTip: + """ + Initialized a branch tip state for a new branch satisfying the given sm_link. + :return: a new branch tip. + """ + + # Find all forks with justified source + tips_with_justified_source = [s for s in branch_tips.values() + if s.eventually_justified_checkpoint.epoch == sm_link.source] + assert len(tips_with_justified_source) > 0 + + # Find and return the most adanced one + most_recent_tip = max(tips_with_justified_source, key=lambda s: s.beacon_state.slot) + return BranchTip(most_recent_tip.beacon_state.copy(), most_recent_tip.attestations.copy(), [], + most_recent_tip.eventually_justified_checkpoint) + + +def _sample_validator_partition(spec, state, epoch, participation_rate, rnd) -> []: + active_validator_indices = spec.get_active_validator_indices(state, epoch) + participants_count = len(active_validator_indices) * participation_rate // 100 + return rnd.sample(active_validator_indices, participants_count) + + +def _compute_validator_partitions(spec, branch_tips, current_links, current_epoch, rnd: random.Random) -> dict[ + SmLink:[int]]: + """ + Note: O(N) complex (N is a number of validators) and might be inefficient with large validator sets + + Uniformly distributes active validators between active forks specified by a given set of sm_links. + Handles two cases: + 1. Single active fork: + Randomly sample a single validator partition taking into account + whether the fork should have a justified checkpoint in the current epoch. + 2. Multiple active forks: + i. sample the majority partition if one of the forks is about to justify during the current epoch, + ii. run through a set of active validators and randomly select a fork for it, + do no consider validators that were sampled into the majority partition. + + Does not take into account validator's effective balance, based on assumption that the EB of every validator + is nearly the same. + + :return: [SmLink: participants] + """ + + justifying_links = [l for l in current_links if l.target == current_epoch] + + # Justifying conflicting checkpoints isn't supported + assert len(justifying_links) < 2 + justifying_link = justifying_links[0] if any(justifying_links) else None + + # Sanity check + for sm_link in current_links: + assert spec.get_current_epoch(branch_tips[sm_link].beacon_state) == current_epoch + + # Case when there is just one active fork + if len(current_links) == 1: + the_sm_link = current_links[0] + + if the_sm_link == justifying_link: + participation_rate = _justifying_participation_rate(rnd) + else: + participation_rate = _under_justifying_participation_rate(rnd) + + state = branch_tips[the_sm_link].beacon_state + participants = _sample_validator_partition(spec, state, current_epoch, participation_rate, rnd) + + return {the_sm_link: participants} + + # Cases with more than one active fork + participants = {l: [] for l in current_links} + + # Move the majority to the branch containing justification target + justifying_participants = [] + if justifying_link is not None: + state = branch_tips[justifying_link].beacon_state + justifying_participants = _sample_validator_partition(spec, + branch_tips[justifying_link].beacon_state, + current_epoch, + _justifying_participation_rate(rnd), + rnd) + + participants[justifying_link] = justifying_participants + + # Collect a set of active validator indexes across all forks + active_validator_per_branch = {} + all_active_validators = set() + for l in current_links: + state = branch_tips[l].beacon_state + active_validator_per_branch[l] = spec.get_active_validator_indices(state, current_epoch) + all_active_validators.update(active_validator_per_branch[l]) + + # Remove validators selected for justifying brach from the pool of active participants + all_active_validators = all_active_validators.difference(justifying_participants) + + # For each index: + # 1) Collect a set of branches where the validators is in active state (except for justifying branch) + # 2) Append the index to the list of participants for a randomly selected branch + for index in all_active_validators: + active_branches = [l for l in current_links if + index in active_validator_per_branch[l] and l not in justifying_links] + participants[tuple(rnd.choice(active_branches))].append(index) + + return participants + + +def _get_eligible_attestations(spec, state, attestations) -> []: + def _get_voting_source(target: spec.Checkpoint) -> spec.Checkpoint: + if target.epoch == spec.get_current_epoch(state): + return state.current_justified_checkpoint + else: + return state.previous_justified_checkpoint + + return [a for a in attestations if + state.slot <= a.data.slot + spec.SLOTS_PER_EPOCH + and a.data.source == _get_voting_source(a.data.target)] + + +def _produce_block(spec, state, attestations, attester_slashings=[]): + """ + Produces a block including as many attestations as it is possible. + :return: Signed block, the post block state and attestations that were not included into the block. + """ + + # Filter out too old attestastions (TODO relax condition for Deneb) + eligible_attestations = _get_eligible_attestations(spec, state, attestations) + + # Prepare attestations + attestation_in_block = eligible_attestations[:spec.MAX_ATTESTATIONS] + + # Create a block with attestations + block = build_empty_block(spec, state) + for a in attestation_in_block: + block.body.attestations.append(a) + + # Add attester slashings + attester_slashings_in_block = attester_slashings[:spec.MAX_ATTESTER_SLASHINGS] + for s in attester_slashings_in_block: + block.body.attester_slashings.append(s) + + # Run state transition and sign off on a block + post_state = state.copy() + + valid = True + try: + spec.process_block(post_state, block) + except AssertionError: + valid = False + + block.state_root = post_state.hash_tree_root() + signed_block = sign_block(spec, post_state, block) + + # Filter out operations only if the block is valid + not_included_attestations = attestations + not_included_attester_slashings = attester_slashings + if valid: + not_included_attestations = [a for a in attestations if a not in attestation_in_block] + not_included_attester_slashings = [s for s in attester_slashings if s not in attester_slashings_in_block] + + # Return a pre state if the block is invalid + if not valid: + post_state = state + + return signed_block, post_state, not_included_attestations, not_included_attester_slashings + + +def _attest_to_slot(spec, state, slot_to_attest, participants_filter=None) -> []: + """ + Creates attestation is a slot respecting participating validators. + :return: produced attestations + """ + + assert slot_to_attest <= state.slot + + committees_per_slot = spec.get_committee_count_per_slot(state, spec.compute_epoch_at_slot(slot_to_attest)) + attestations_in_slot = [] + for index in range(committees_per_slot): + beacon_committee = spec.get_beacon_committee(state, slot_to_attest, index) + participants = beacon_committee if participants_filter is None else participants_filter(beacon_committee) + if any(participants): + attestation = get_valid_attestation( + spec, + state, + slot_to_attest, + index=index, + signed=True, + filter_participant_set=participants_filter + ) + attestations_in_slot.append(attestation) + + return attestations_in_slot + + +def _compute_eventually_justified_epoch(spec, state, attestations, participants): + # If not all attestations are included on chain + # and attestation.data.target.epoch > beacon_state.current_justified_checkpoint.epoch + # compute eventually_justified_checkpoint, a would be state.current_justified_checkpoint if all attestations + # were included; this computation respects the validator partition that was building the branch + if len(attestations) > 0 \ + and attestations[0].data.target.epoch > state.current_justified_checkpoint.epoch \ + and attestations[0].data.target.epoch > spec.GENESIS_EPOCH: + branch_tip = BranchTip(state, attestations, participants, state.current_justified_checkpoint) + _, new_branch_tip = _advance_branch_to_next_epoch(spec, branch_tip, enable_attesting=False) + + return new_branch_tip.beacon_state.current_justified_checkpoint + else: + return state.current_justified_checkpoint + + +def _advance_branch_to_next_epoch(spec, branch_tip, enable_attesting=True): + """ + Advances a state of the block tree branch to the next epoch + respecting validators participanting in building and attesting to this branch. + + The returned beacon state is advanced to the first slot of the next epoch while no block for that slot is created, + produced attestations that aren't yet included on chain are preserved for the future inclusion. + """ + + def participants_filter(comm): + return [index for index in comm if index in branch_tip.participants] + + signed_blocks = [] + attestations = branch_tip.attestations.copy() + state = branch_tip.beacon_state.copy() + current_epoch = spec.get_current_epoch(state) + target_slot = spec.compute_start_slot_at_epoch(current_epoch + 1) + + while state.slot < target_slot: + # Produce block if the proposer is among participanting validators + proposer = spec.get_beacon_proposer_index(state) + if state.slot > spec.GENESIS_SLOT and proposer in branch_tip.participants: + signed_block, state, attestations, _ = _produce_block(spec, state, attestations) + signed_blocks.append(signed_block) + + if enable_attesting: + # Produce attestations + attestations_in_slot = _attest_to_slot(spec, state, state.slot, participants_filter) + # And prepend them to the list + attestations = list(attestations_in_slot) + attestations + + # Advance a slot + next_slot(spec, state) + + # Cleanup attestations by removing outdated ones + attestations = [a for a in attestations if + a.data.target.epoch in (spec.get_previous_epoch(state), spec.get_current_epoch(state))] + + eventually_justified_checkpoint = _compute_eventually_justified_epoch(spec, state, attestations, + branch_tip.participants) + + return signed_blocks, BranchTip(state, attestations, branch_tip.participants, eventually_justified_checkpoint) + + +def _any_change_to_validator_partitions(spec, sm_links, current_epoch, anchor_epoch) -> bool: + """ + Returns ``true`` if validator partitions should be re-shuffled to advance branches in the current epoch: + 1. The first epoch after the anchor epoch always requires a new shuffling. + 2. Previous epoch has justified checkpoints. + Therefore, new supermajority links may need to be processed during the current epoch, + thus new block tree branches with new validator partitions may need to be created. + 3. Current epoch has justified checkpoint. + Therefore, the majority of validators must be moved to the justifying branch. + """ + assert current_epoch > anchor_epoch + + previous_epoch = current_epoch - 1 + + if previous_epoch == anchor_epoch: + return True + + for l in sm_links: + if l.target == current_epoch or l.target == previous_epoch: + return True + + return False + + +def _attesters_in_block(spec, epoch_state, signed_block, target_epoch): + block = signed_block.message + attesters = set() + for a in block.body.attestations: + if a.data.target.epoch == target_epoch: + attesters.update(spec.get_attesting_indices(epoch_state, a.data, a.aggregation_bits)) + return attesters + + +def _print_block(spec, epoch_state, signed_block): + block = signed_block.message + if spec.get_current_epoch(epoch_state) > spec.GENESIS_EPOCH: + prev_attesters = _attesters_in_block(spec, epoch_state, signed_block, spec.get_previous_epoch(epoch_state)) + else: + prev_attesters = set() + + curr_attesters = _attesters_in_block(spec, epoch_state, signed_block, spec.get_current_epoch(epoch_state)) + prev_attester_str = 'a_prev=' + str(prev_attesters) if any(prev_attesters) else 'a_prev={}' + curr_attester_str = 'a_curr=' + str(curr_attesters) if any(curr_attesters) else 'a_curr={}' + + return 'b(r=' + str(spec.hash_tree_root(block))[:6] + ', p=' + str( + block.proposer_index) + ', ' + prev_attester_str + ', ' + curr_attester_str + ')' + + +def _print_slot_range(spec, root_state, signed_blocks, start_slot, end_slot): + ret = "" + epoch_state = root_state.copy() + for slot in range(start_slot, end_slot): + transition_to(spec, epoch_state, slot) + blocks_in_slot = [b for b in signed_blocks if b.message.slot == slot] + if ret != "": + ret = ret + " <- " + if any(blocks_in_slot): + ret = ret + "s(" + str(slot) + ", " + _print_block(spec, epoch_state, blocks_in_slot[0]) + ")" + else: + ret = ret + "s(" + str(slot) + ", _)" + + return ret + + +def _print_epoch(spec, epoch_state, signed_blocks): + epoch = spec.get_current_epoch(epoch_state) + start_slot = spec.compute_start_slot_at_epoch(epoch) + return _print_slot_range(spec, epoch_state, signed_blocks, start_slot, start_slot + spec.SLOTS_PER_EPOCH) + + +def _print_block_tree(spec, root_state, signed_blocks): + start_slot = signed_blocks[0].message.slot + end_slot = signed_blocks[len(signed_blocks) - 1].message.slot + 1 + return _print_slot_range(spec, root_state, signed_blocks, start_slot, end_slot) + + +def _advance_state_to_anchor_epoch(spec, state, anchor_epoch, debug) -> ([], BranchTip): + signed_blocks = [] + + genesis_tip = BranchTip(state.copy(), [], [*range(0, len(state.validators))], + state.current_justified_checkpoint) + + # Advance the state to the anchor_epoch + anchor_tip = genesis_tip + for epoch in range(spec.GENESIS_EPOCH, anchor_epoch + 1): + pre_state = anchor_tip.beacon_state + new_signed_blocks, anchor_tip = _advance_branch_to_next_epoch(spec, anchor_tip) + signed_blocks = signed_blocks + new_signed_blocks + if debug: + post_state = anchor_tip.beacon_state + print('\nepoch', str(epoch) + ':') + print('branch(*, *):', _print_epoch(spec, pre_state, new_signed_blocks)) + print(' ', len(anchor_tip.participants), 'participants:', anchor_tip.participants) + print(' ', 'state.current_justified_checkpoint:', + '(epoch=' + str(post_state.current_justified_checkpoint.epoch) + + ', root=' + str(post_state.current_justified_checkpoint.root)[:6] + ')') + print(' ', 'eventually_justified_checkpoint:', + '(epoch=' + str(anchor_tip.eventually_justified_checkpoint.epoch) + + ', root=' + str(anchor_tip.eventually_justified_checkpoint.root)[:6] + ')') + + return signed_blocks, anchor_tip + + +def _generate_sm_link_tree(spec, genesis_state, sm_links, rnd: random.Random, debug) -> ([], BranchTip): + """ + Generates a sequence of blocks satisfying a tree of supermajority links specified in the sm_links list, + i.e. a sequence of blocks with attestations required to create given supermajority links. + + The block generation strategy is to run through a span of epochs covered by the supermajority links + and for each epoch of the span apply the following steps: + 1. Obtain a list of supermajority links covering the epoch. + 2. Create a new block tree branch (fork) for every newly observed supermajority link. + 3. Randomly sample all active validators between a set of forks that are being advanced in the epoch. + Validator partitions are disjoint and are changing only at the epoch boundary. + If no new branches are created in the current epoch then partitions from the previous epoch will be used + to advahce the state of every fork to the next epoch. + 4. Advance every fork to the next epoch respecting a validator partition assigned to it in the current epoch. + Preserve attestations produced but not yet included on chain for potential inclusion in the next epoch. + 5. Justify required checkpoints by moving the majority of validators to the justifying fork, + this is taken into account by step (3). + + :return: Sequence of signed blocks oredered by a slot number. + """ + assert any(sm_links) + + # Find anchor epoch + anchor_epoch = min(sm_links, key=lambda l: l.source).source + + signed_blocks, anchor_tip = _advance_state_to_anchor_epoch(spec, genesis_state, anchor_epoch, debug) + + # branch_tips hold the most recent state, validator partition and not included attestations for every fork + # Initialize branch tips with the anchor tip + anchor_link = SmLink((spec.GENESIS_EPOCH, anchor_epoch)) + branch_tips = {anchor_link: anchor_tip} + + highest_target_sm_link = max(sm_links, key=lambda l: l.target) + + # Finish at after the highest justified checkpoint + for current_epoch in range(anchor_epoch + 1, highest_target_sm_link.target + 1): + # Obtain sm links that span over the current epoch + current_epoch_sm_links = [l for l in sm_links if l.source < current_epoch <= l.target] + + # Initialize new forks + for l in (l for l in current_epoch_sm_links if branch_tips.get(l) is None): + new_branch_tip = _create_new_branch_tip(spec, branch_tips, l) + # Abort the test if any sm_links constraint appears to be unreachable + # because the justification of the source checkpoint hasn't been realized on chain yet + if l.target == current_epoch and new_branch_tip.beacon_state.current_justified_checkpoint.epoch < l.source: + return [], new_branch_tip + + branch_tips[l] = new_branch_tip + + # Reshuffle partitions if needed + if _any_change_to_validator_partitions(spec, sm_links, current_epoch, anchor_epoch): + partitions = _compute_validator_partitions(spec, branch_tips, current_epoch_sm_links, current_epoch, rnd) + for l in partitions.keys(): + old_tip_state = branch_tips[l] + new_tip_state = BranchTip(old_tip_state.beacon_state, old_tip_state.attestations, partitions[l], + old_tip_state.eventually_justified_checkpoint) + branch_tips[l] = new_tip_state + + # Debug checks + if debug: + print('\nepoch', str(current_epoch) + ':') + # Partitions are disjoint + for l1 in current_epoch_sm_links: + l1_participants = branch_tips[l1].participants + for l2 in current_epoch_sm_links: + if l1 != l2: + l2_participants = branch_tips[l2].participants + intersection = set(l1_participants).intersection(l2_participants) + assert len(intersection) == 0, \ + str(l1) + ' and ' + str(l2) + ' has common participants: ' + str(intersection) + + # Advance every branch taking into account attestations from past epochs and voting partitions + for sm_link in current_epoch_sm_links: + branch_tip = branch_tips[sm_link] + assert spec.get_current_epoch(branch_tip.beacon_state) == current_epoch, \ + 'Unexpected current_epoch(branch_tip.beacon_state): ' + str( + spec.get_current_epoch(branch_tip.beacon_state)) + ' != ' + str(current_epoch) + new_signed_blocks, new_branch_tip = _advance_branch_to_next_epoch(spec, branch_tip) + + # Run sanity checks + post_state = new_branch_tip.beacon_state + assert spec.get_current_epoch(post_state) == current_epoch + 1, \ + 'Unexpected post_state epoch: ' + str(spec.get_current_epoch(post_state)) + ' != ' + str( + current_epoch + 1) + if sm_link.target == current_epoch: + assert post_state.previous_justified_checkpoint.epoch == sm_link.source, \ + 'Unexpected previous_justified_checkpoint.epoch: ' + str( + post_state.previous_justified_checkpoint.epoch) + ' != ' + str(sm_link.source) + assert new_branch_tip.eventually_justified_checkpoint.epoch == sm_link.target, \ + 'Unexpected eventually_justified_checkpoint.epoch: ' + str( + new_branch_tip.eventually_justified_checkpoint.epoch) + ' != ' + str(sm_link.target) + elif (sm_link.source != new_branch_tip.eventually_justified_checkpoint.epoch): + # Abort the test as the justification of the source checkpoint can't be realized on chain + # because of the lack of the block space + return [], new_branch_tip + + # If the fork won't be advanced in the future epochs + # ensure 1) all yet not included attestations are included on chain by advancing it to epoch N+1 + # 2) justification is realized by advancing it to epoch N+2 + is_fork_advanced_in_future = any((l for l in sm_links if l.source == sm_link.target)) + if sm_link.target == current_epoch and not is_fork_advanced_in_future: + advanced_branch_tip = new_branch_tip + + # Advance to N+1 if state.current_justified_checkpoint.epoch < eventually_justified_checkpoint.epoch + current_justified_epoch = new_branch_tip.beacon_state.current_justified_checkpoint.epoch + eventually_justified_epoch = new_branch_tip.eventually_justified_checkpoint.epoch + if current_justified_epoch < eventually_justified_epoch: + advanced_signed_blocks, advanced_branch_tip = _advance_branch_to_next_epoch(spec, new_branch_tip, + enable_attesting=False) + new_signed_blocks = new_signed_blocks + advanced_signed_blocks + + # Build a block in the next epoch to justify the target on chain + state = advanced_branch_tip.beacon_state + while (spec.get_beacon_proposer_index(state) not in advanced_branch_tip.participants): + next_slot(spec, state) + + tip_block, _, _, _ = _produce_block(spec, state, []) + new_signed_blocks.append(tip_block) + + assert state.current_justified_checkpoint.epoch == sm_link.target, \ + 'Unexpected state.current_justified_checkpoint: ' + str( + state.current_justified_checkpoint.epoch) + ' != ' + str(sm_link.target) + + # Debug output + if debug: + print('branch' + str(sm_link) + ':', + _print_epoch(spec, branch_tips[sm_link].beacon_state, new_signed_blocks)) + print(' ', len(branch_tips[sm_link].participants), 'participants:', + new_branch_tip.participants) + print(' ', 'state.current_justified_checkpoint:', + '(epoch=' + str(post_state.current_justified_checkpoint.epoch) + + ', root=' + str(post_state.current_justified_checkpoint.root)[:6] + ')') + print(' ', 'eventually_justified_checkpoint:', + '(epoch=' + str(new_branch_tip.eventually_justified_checkpoint.epoch) + + ', root=' + str(new_branch_tip.eventually_justified_checkpoint.root)[:6] + ')') + + # Debug checks + if debug: + # Proposers are aligned with the partition + unexpected_proposers = [b.message.proposer_index for b in new_signed_blocks if + b.message.proposer_index not in branch_tip.participants] + assert len(unexpected_proposers) == 0, \ + 'Unexpected proposer: ' + str(unexpected_proposers[0]) + + # Attesters are aligned with the partition + current_epoch_state = branch_tips[sm_link].beacon_state + for b in new_signed_blocks: + # Attesting indexes from on chain attestations + attesters = _attesters_in_block(spec, current_epoch_state, b, current_epoch) + # Attesting indexes from not yet included attestations + for a in new_branch_tip.attestations: + if a.data.target.epoch == current_epoch: + attesters.update( + spec.get_attesting_indices(current_epoch_state, a.data, a.aggregation_bits)) + unexpected_attesters = attesters.difference(branch_tip.participants) + assert len(unexpected_attesters) == 0, \ + 'Unexpected attester: ' + str(unexpected_attesters.pop()) + ', slot ' + str(b.message.slot) + + # Store the result + branch_tips[sm_link] = new_branch_tip + signed_blocks = signed_blocks + new_signed_blocks + + # Sort blocks by a slot + signed_block_messages = [ProtocolMessage(b) for b in signed_blocks] + return sorted(signed_block_messages, key=lambda b: b.payload.message.slot), branch_tips[highest_target_sm_link] + + +def _spoil_block(spec, rnd: random.Random, signed_block): + signed_block.message.state_root = spec.Root(rnd.randbytes(32)) + + +def _spoil_attester_slashing(spec, rnd: random.Random, attester_slashing): + attester_slashing.attestation_2.data = attester_slashing.attestation_1.data + + +def _spoil_attestation(spec, rnd: random.Random, attestation): + attestation.data.target.epoch = spec.GENESIS_EPOCH + + +def _generate_block_tree(spec, + anchor_tip: BranchTip, + rnd: random.Random, + debug, + block_parents, + with_attester_slashings, + with_invalid_messages) -> ([], [], []): + in_block_attestations = anchor_tip.attestations.copy() + post_states = [anchor_tip.beacon_state.copy()] + current_slot = anchor_tip.beacon_state.slot + block_index = 1 + block_tree_tips = set([0]) + in_block_attester_slashings = [] + attester_slashings_count = 0 + out_of_block_attestation_messages = [] + out_of_block_attester_slashing_messages = [] + signed_block_messages = [] + + while block_index < len(block_parents): + # Propose a block if slot shouldn't be empty + if rnd.randint(1, 100) > EMPTY_SLOTS_RATE: + # Advance parent state to the current slot + parent_index = block_parents[block_index] + parent_state = post_states[parent_index].copy() + transition_to(spec, parent_state, current_slot) + + # Filter out non-viable attestations + in_block_attestations = [a for a in in_block_attestations + if parent_state.slot <= a.data.slot + spec.SLOTS_PER_EPOCH] + + # Produce block + proposer = spec.get_beacon_proposer_index(parent_state) + if parent_state.validators[proposer].slashed or ( + with_invalid_messages and rnd.randint(0, 99) < INVALID_MESSAGES_RATE): + # Do not include attestations and slashings into invalid block + # as clients may opt in to process or not process attestations contained by invalid block + signed_block, _, _, _ = _produce_block(spec, parent_state, [], []) + _spoil_block(spec, rnd, signed_block) + signed_block_messages.append(ProtocolMessage(signed_block, False)) + # Append the parent state as the post state as if the block were not applied + post_states.append(parent_state) + else: + signed_block, post_state, in_block_attestations, in_block_attester_slashings = _produce_block( + spec, parent_state, in_block_attestations, in_block_attester_slashings) + + # Valid block + signed_block_messages.append(ProtocolMessage(signed_block, True)) + post_states.append(post_state) + + # Update tips + block_tree_tips.discard(parent_index) + block_tree_tips.add(block_index) + + # Next block + block_index += 1 + + # Attest to randomly selected tips + def split_list(lst, n): + k, m = divmod(len(lst), n) + return [lst[i * k + min(i, m):(i + 1) * k + min(i + 1, m)] for i in range(n)] + + attesting_tips = rnd.sample(sorted(block_tree_tips), min(len(block_tree_tips), MAX_TIPS_TO_ATTEST)) + validator_count = len(post_states[attesting_tips[0]].validators) + attesters = split_list([i for i in range(validator_count)], len(attesting_tips)) + for index, attesting_block_index in enumerate(attesting_tips): + # Advance the state to the current slot + attesting_state = post_states[attesting_block_index] + transition_to(spec, attesting_state, current_slot) + + # Attest to the block + attestations_in_slot = _attest_to_slot(spec, attesting_state, attesting_state.slot, + lambda comm: [i for i in comm if i in attesters[index]]) + + # Sample on chain and off chain attestations + for a in attestations_in_slot: + choice = rnd.randint(0, 99) + if choice < OFF_CHAIN_ATTESTATION_RATE: + if with_invalid_messages and rnd.randint(0, 99) < INVALID_MESSAGES_RATE: + _spoil_attestation(spec, rnd, a) + attestation_message = ProtocolMessage(a, False) + else: + attestation_message = ProtocolMessage(a, True) + out_of_block_attestation_messages.append(attestation_message) + elif choice < OFF_CHAIN_ATTESTATION_RATE + ON_CHAIN_ATTESTATION_RATE: + in_block_attestations.insert(0, a) + else: + out_of_block_attestation_messages.append(ProtocolMessage(a, True)) + in_block_attestations.insert(0, a) + + # Create attester slashing + if with_attester_slashings and attester_slashings_count < MAX_ATTESTER_SLASHINGS: + if rnd.randint(0, 99) < ATTESTER_SLASHINGS_RATE: + state = post_states[attesting_tips[0]] + indices = [rnd.randint(0, len(state.validators) - 1)] + attester_slashing = get_valid_attester_slashing_by_indices(spec, state, indices, + slot=current_slot, + signed_1=True, + signed_2=True) + + choice = rnd.randint(0, 99) + if choice < OFF_CHAIN_SLASHING_RATE: + if with_invalid_messages and rnd.randint(0, 99) < INVALID_MESSAGES_RATE: + _spoil_attester_slashing(spec, rnd, attester_slashing) + attester_slashing_message = ProtocolMessage(attester_slashing, False) + else: + attester_slashing_message = ProtocolMessage(attester_slashing, True) + out_of_block_attester_slashing_messages.append(attester_slashing_message) + elif choice < OFF_CHAIN_SLASHING_RATE + ON_CHAIN_SLASHING_RATE: + in_block_attester_slashings.append(attester_slashing) + else: + out_of_block_attester_slashing_messages.append(ProtocolMessage(attester_slashing, True)) + in_block_attester_slashings.append(attester_slashing) + + attester_slashings_count += 1 + + # Next slot + current_slot += 1 + + if debug: + print('\nblock_tree:') + print('blocks: ', _print_block_tree(spec, post_states[0], [b.payload for b in signed_block_messages])) + print(' ', 'state.current_justified_checkpoint:', + '(epoch=' + str(post_states[len(post_states) - 1].current_justified_checkpoint.epoch) + + ', root=' + str(post_states[len(post_states) - 1].current_justified_checkpoint.root)[:6] + ')') + + print('on_block:') + print(' ', 'count =', len(signed_block_messages)) + print(' ', 'valid =', len([b for b in signed_block_messages if b.valid])) + print('on_attestation:') + print(' ', 'count =', len(out_of_block_attestation_messages)) + print(' ', 'valid =', len([a for a in out_of_block_attestation_messages if a.valid])) + print('on_attester_slashing:') + print(' ', 'count =', len(out_of_block_attester_slashing_messages)) + print(' ', 'valid =', len([s for s in out_of_block_attester_slashing_messages if s.valid])) + + return (sorted(signed_block_messages, key=lambda b: b.payload.message.slot), + sorted(out_of_block_attestation_messages, key=lambda a: a.payload.data.slot), + sorted(out_of_block_attester_slashing_messages, key=lambda a: a.payload.attestation_1.data.slot)) + + +def _print_head(spec, store): + head = spec.get_head(store) + weight = spec.get_weight(store, head) + state = store.checkpoint_states[store.justified_checkpoint] + total_active_balance = spec.get_total_active_balance(state) + + return '(slot=' + str(store.blocks[head].slot) + ', root=' + str(head)[:6] + ', weight=' + str( + weight * 100 // total_active_balance) + '%)' + + +def _on_tick_and_append_step(spec, store, slot, test_steps): + time = slot * spec.config.SECONDS_PER_SLOT + store.genesis_time + on_tick_and_append_step(spec, store, time, test_steps) + assert store.time == time + + +@with_altair_and_later +@spec_state_test +def test_sm_links_tree_model(spec, + state, + debug=False, + seed=1, + sm_links=None, + block_parents=None, + with_attester_slashings=False, + with_invalid_messages=False): + # This test is mainly used for the test generation purposes + # Thus seed, sm_links and block_parents are provided by the generator + # Define sm_links, seed and block_parents explicitly to execute a certain run of this test + if sm_links is None or block_parents is None: + return + + assert (1, 2) not in sm_links, '(1, 2) sm link is not supported due to unsatisfiability' + + sm_links = [SmLink(l) for l in sm_links] + + # Find a reachable solution trying with different seeds if needed + # sm_links constraints may not have a solution beacause of the randomization affecting validator partitions + signed_block_messages = [] + highest_tip = BranchTip(state, [], [], state.current_justified_checkpoint) + while True: + if debug: + print('\nseed:', seed) + print('sm_links:', sm_links) + print('block_parents:', block_parents) + + rnd = random.Random(seed) + signed_block_messages, highest_tip = _generate_sm_link_tree(spec, state, sm_links, rnd, debug) + if len(signed_block_messages) > 0: + break + + new_seed = rnd.randint(1, 10000) + print('\nUnsatisfiable constraints: sm_links: ' + str(sm_links) + ', seed=' + str( + seed) + ', will retry with seed=' + str(new_seed)) + seed = new_seed + + # Block tree model + attestation_messages = [] + attester_slashing_messages = [] + if block_parents is not None and any(block_parents): + block_tree, attestation_messages, attester_slashing_messages = _generate_block_tree( + spec, highest_tip, rnd, debug, block_parents, with_attester_slashings, with_invalid_messages) + # Merge block_tree and sm_link_tree blocks + block_tree_root_slot = block_tree[0].payload.message.slot + signed_block_messages = [b for b in signed_block_messages if b.payload.message.slot < block_tree_root_slot] + signed_block_messages = signed_block_messages + block_tree + + # Yield run parameters + yield 'seed', 'meta', seed + yield 'sm_links', 'meta', str(sm_links) + yield 'block_parents', 'meta', str(block_parents) + + test_steps = [] + # Store initialization + store, anchor_block = get_genesis_forkchoice_store_and_block(spec, state) + yield 'anchor_state', state + yield 'anchor_block', anchor_block + _on_tick_and_append_step(spec, store, state.slot, test_steps) + + # Apply generated messages + max_block_slot = max(b.payload.message.slot for b in signed_block_messages) + max_attestation_slot = max(a.payload.data.slot for a in attestation_messages) if any(attestation_messages) else 0 + max_slashing_slot = max( + s.payload.attestation_1.data.slot for s in attester_slashing_messages) if any(attester_slashing_messages) else 0 + + start_slot = min(b.payload.message.slot for b in signed_block_messages) + end_slot = max(max_block_slot, max_attestation_slot, max_slashing_slot) + 1 + + # Advance time to start_slot + _on_tick_and_append_step(spec, store, start_slot, test_steps) + + # Apply messages to store + for slot in range(start_slot, end_slot + 1): + # on_tick + _on_tick_and_append_step(spec, store, slot, test_steps) + + # on_attestation for attestations from the previous slot + for attestation_message in (a for a in attestation_messages if a.payload.data.slot == slot - 1): + yield from add_attestation(spec, store, attestation_message.payload, + test_steps, valid=attestation_message.valid) + + # on_attester_slashing for slashing from the previous slot + for attester_slashing_message in (s for s in attester_slashing_messages + if s.payload.attestation_1.data.slot == slot - 1): + yield from add_attester_slashing(spec, store, attester_slashing_message.payload, + test_steps, valid=attester_slashing_message.valid) + + # on_block for blocks from the current slot + for signed_block_message in (b for b in signed_block_messages if b.payload.message.slot == slot): + yield from add_block(spec, store, signed_block_message.payload, test_steps, signed_block_message.valid) + + block_root = signed_block_message.payload.message.hash_tree_root() + if signed_block_message.valid: + assert store.blocks[block_root] == signed_block_message.payload.message + else: + assert block_root not in store.blocks.values() + + if debug: + print(' head: ' + _print_head(spec, store)) + + output_store_checks(spec, store, test_steps, with_filtered_block_weights=True) + + yield 'steps', test_steps + + +def _should_justifiy_epoch(parents, block_epochs, current_justifications, previous_justifications, block, epoch) -> bool: + if current_justifications[block]: + return True + + # Check if any child of the block justifies the epoch + for c in (b for b, p in enumerate(parents) if p == block): + if previous_justifications[c]: + return True + + return False + + +def _generate_filter_block_tree(spec, genesis_state, block_epochs, parents, previous_justifications, + current_justifications, rnd: random.Random, debug) -> ([], []): + JUSTIFYING_SLOT = 2 * spec.SLOTS_PER_EPOCH // 3 + 1 + JUSTIFYING_SLOT_COUNT = spec.SLOTS_PER_EPOCH - JUSTIFYING_SLOT + + anchor_epoch = block_epochs[0] + + # Run constraint checks before starting to generate blocks + for epoch in range(anchor_epoch + 1, max(block_epochs) + 1): + current_blocks = [i for i, e in enumerate(block_epochs) if e == epoch] + assert len(current_blocks) <= spec.SLOTS_PER_EPOCH, 'Number of blocks does not fit into an epoch=' + str(epoch) + + justifying_blocks = [b for b in current_blocks if _should_justifiy_epoch( + parents, block_epochs, current_justifications, previous_justifications, b, epoch)] + + # There should be enough slots to propose all blocks that are required to justify the epoch + assert len(justifying_blocks) <= JUSTIFYING_SLOT_COUNT, \ + 'Not enough slots to accommodate blocks justifying epoch=' + str(epoch) + + signed_blocks, anchor_tip = _advance_state_to_anchor_epoch(spec, genesis_state, anchor_epoch, debug) + + block_tips = [None for _ in range(0, len(block_epochs))] + # Initialize with the anchor block + block_tips[0] = anchor_tip + + for epoch in range(anchor_epoch + 1, max(block_epochs) + 1): + current_blocks = [i for i, e in enumerate(block_epochs) if e == epoch] + if len(current_blocks) == 0: + continue + + # Case 2. Blocks are from disjoint subtrees -- not supported yet + assert len( + set([a for i, a in enumerate(parents) if i in current_blocks])) == 1, 'Disjoint trees are not supported' + + # Case 1. Blocks have common ancestor + a = parents[current_blocks[0]] + ancestor_tip = block_tips[a].copy() + + state = ancestor_tip.beacon_state + attestations = ancestor_tip.attestations + + justifying_blocks = [b for b in current_blocks if _should_justifiy_epoch( + parents, block_epochs, current_justifications, previous_justifications, b, epoch)] + + common_prefix_len = min(JUSTIFYING_SLOT, spec.SLOTS_PER_EPOCH - len(current_blocks)) + threshold_slot = spec.compute_start_slot_at_epoch(epoch) + common_prefix_len + + # Build the chain up to but excluding a block that will justify current checkpoint + while (state.slot < threshold_slot): + # Do not include attestations into blocks + if (state.slot < spec.compute_start_slot_at_epoch(epoch)): + new_block, state, _, _ = _produce_block(spec, state, []) + signed_blocks.append(new_block) + else: + # Prevent previous epoch from being accidentally justified + # by filtering out previous epoch attestations + curr_epoch_attestations = [a for a in attestations if + epoch == spec.compute_epoch_at_slot(a.data.slot)] + other_attestations = [a for a in attestations if a not in curr_epoch_attestations] + new_block, state, curr_epoch_attestations, _ = _produce_block(spec, state, curr_epoch_attestations) + attestations = other_attestations + curr_epoch_attestations + signed_blocks.append(new_block) + + # Attest + curr_slot_attestations = _attest_to_slot(spec, state, state.slot) + attestations = curr_slot_attestations + attestations + + # Next slot + next_slot(spec, state) + + common_state = state + + # Assumption: one block is enough to satisfy previous_justifications[b] and current_justifications[b], + # i.e. block capacity is enough to accommodate attestations to justify previus and current epoch checkpoints + # if that needed. Considering that most of attestations were already included into the common chain prefix, + # we assume it is possible + empty_slot_count = spec.SLOTS_PER_EPOCH - common_prefix_len - len(current_blocks) + block_distribution = current_blocks.copy() + [-1 for _ in range(0, empty_slot_count)] + + # Randomly distribute blocks across slots + rnd.shuffle(block_distribution) + + # Move all blocks that require to justify current epoch to the end to increase the chance of justification + block_distribution = [b for b in block_distribution if b not in justifying_blocks] + block_distribution = block_distribution + justifying_blocks + + for index, block in enumerate(block_distribution): + slot = threshold_slot + index + state = common_state.copy() + + # Advance state to the slot + if state.slot < slot: + transition_to(spec, state, slot) + + # Propose a block if slot isn't empty + block_attestations = [] + if block > -1: + previous_epoch_attestations = [a for a in attestations if + epoch == spec.compute_epoch_at_slot(a.data.slot) + 1] + current_epoch_attestations = [a for a in attestations if + epoch == spec.compute_epoch_at_slot(a.data.slot)] + if (previous_justifications[block]): + block_attestations = block_attestations + previous_epoch_attestations + if (current_justifications[block]): + block_attestations = block_attestations + current_epoch_attestations + + # Propose block + new_block, state, _, _ = _produce_block(spec, state, block_attestations) + signed_blocks.append(new_block) + + # Attest + # TODO pick a random tip to make attestation with if the slot is empty + curr_slot_attestations = _attest_to_slot(spec, state, state.slot) + attestations = curr_slot_attestations + attestations + + # Next slot + next_slot(spec, state) + + if block > -1: + not_included_attestations = [a for a in attestations if a not in block_attestations] + + check_up_state = state.copy() + spec.process_justification_and_finalization(check_up_state) + + if current_justifications[block]: + assert check_up_state.current_justified_checkpoint.epoch == epoch, 'Unexpected current_jusitified_checkpoint.epoch: ' + str( + check_up_state.current_justified_checkpoint.epoch) + ' != ' + str(epoch) + elif previous_justifications[block]: + assert check_up_state.current_justified_checkpoint.epoch + 1 == epoch, 'Unexpected current_jusitified_checkpoint.epoch: ' + str( + check_up_state.current_justified_checkpoint.epoch) + ' != ' + str(epoch - 1) + + block_tips[block] = BranchTip(state, not_included_attestations, [*range(0, len(state.validators))], + check_up_state.current_justified_checkpoint) + + return signed_blocks, block_tips + + +@with_altair_and_later +@spec_state_test +def test_filter_block_tree_model(spec, state, model_params=None, debug=False, seed=1): + if model_params is None: + return + + print('\nseed:', seed) + print('predicates:', str(model_params['predicates'])) + print('model_params:', str(model_params)) + + block_epochs = model_params['block_epochs'] + parents = model_params['parents'] + previous_justifications = model_params['previous_justifications'] + current_justifications = model_params['current_justifications'] + + store_justified_epoch = model_params['store_justified_epoch'] + target_block = model_params['target_block'] + + anchor_epoch = block_epochs[0] + + # Ensure that there is no attempt to justify GENESIS_EPOCH + 1 as it is not supported by the protocol + assert store_justified_epoch != spec.GENESIS_EPOCH + 1, 'Justification of epoch 1 is not supported by the protocol' + + # Ensure that epoch(block) == epoch(parent) + 1 + for b in range(1, len(block_epochs)): + assert block_epochs[b] == block_epochs[parents[b]] + 1, 'epoch(' + str(b) + ') != epoch(' + str( + parents[b]) + ') + 1, block_epochs=' + str(block_epochs) + ', parents=' + str(parents) + + # Ensure that a descendant doesn't attempt to justify the previous epoch checkpoint + # if it has already been justified by its ancestor + for b in range(1, len(block_epochs)): + if previous_justifications[b]: + a = parents[b] + assert not current_justifications[a], str(b) + ' attempts to justify already justified epoch' + + rnd = random.Random(seed) + signed_blocks, post_block_tips = _generate_filter_block_tree(spec, + state, + block_epochs, + parents, + previous_justifications, + current_justifications, + rnd, + debug) + + # Yield run parameters + yield 'seed', 'meta', seed + yield 'model_params', 'meta', model_params + + test_steps = [] + # Store initialization + store, anchor_block = get_genesis_forkchoice_store_and_block(spec, state) + yield 'anchor_state', state + yield 'anchor_block', anchor_block + current_time = state.slot * spec.config.SECONDS_PER_SLOT + store.genesis_time + on_tick_and_append_step(spec, store, current_time, test_steps) + assert store.time == current_time + + # Apply generated blocks + for signed_block in signed_blocks: + block = signed_block.message + yield from tick_and_add_block(spec, store, signed_block, test_steps) + block_root = block.hash_tree_root() + assert store.blocks[block_root] == block + + # Advance the store to the current epoch as per model + current_epoch_slot = spec.compute_start_slot_at_epoch(model_params['current_epoch']) + current_epoch_time = state.genesis_time + current_epoch_slot * spec.config.SECONDS_PER_SLOT + if store.time < current_epoch_time: + on_tick_and_append_step(spec, store, current_epoch_time, test_steps) + + current_epoch = spec.get_current_store_epoch(store) + # Ensure the epoch is correct + assert current_epoch == model_params['current_epoch'] + # Ensure the store.justified_checkpoint.epoch is as expected + assert store.justified_checkpoint.epoch == store_justified_epoch + # Ensure the target block is in filtered_blocks + target_block_root = spec.hash_tree_root(post_block_tips[target_block].beacon_state.latest_block_header) + + # Check predicates + predicates = model_params['predicates'] + if predicates['store_je_eq_zero']: + assert store.justified_checkpoint.epoch == spec.GENESIS_EPOCH, "store_je_eq_zero not satisfied" + + if predicates['block_is_leaf']: + assert not any( + b for b in store.blocks.values() if b.parent_root == target_block_root), "block_is_leaf not satisfied" + else: + assert any( + b for b in store.blocks.values() if b.parent_root == target_block_root), "block_is_leaf not satisfied" + + voting_source = spec.get_voting_source(store, target_block_root) + if predicates['block_vse_eq_store_je']: + assert voting_source.epoch == store.justified_checkpoint.epoch, "block_vse_eq_store_je not satisfied" + else: + assert voting_source.epoch != store.justified_checkpoint.epoch, "block_vse_eq_store_je not satisfied" + + if predicates['block_vse_plus_two_ge_curr_e']: + assert voting_source.epoch + 2 >= current_epoch, "block_vse_plus_two_ge_curr_e not satisfied" + else: + assert voting_source.epoch + 2 < current_epoch, "block_vse_plus_two_ge_curr_e not satisfied" + + # Ensure the target block is in filtered blocks if it is a leaf and eligible + if (predicates['block_is_leaf'] + and (predicates['store_je_eq_zero'] + or predicates['block_vse_eq_store_je'] + or predicates['block_vse_plus_two_ge_curr_e'])): + assert target_block_root in spec.get_filtered_block_tree(store).keys() + + output_store_checks(spec, store, test_steps, with_filtered_block_weights=True) + + yield 'steps', test_steps diff --git a/tests/formats/fork_choice/README.md b/tests/formats/fork_choice/README.md index 1258a66c06..7a3aeab282 100644 --- a/tests/formats/fork_choice/README.md +++ b/tests/formats/fork_choice/README.md @@ -177,6 +177,10 @@ finalized_checkpoint: { root: string, -- Encoded 32-byte value from store.finalized_checkpoint.root } proposer_boost_root: string -- Encoded 32-byte value from store.proposer_boost_root +viable_for_head_roots_and_weights: [{ + root: string, -- Encoded 32-byte value of filtered_block_tree leaf blocks + weight: int -- Integer value from get_weight(store, viable_block_root) +}] ``` Additionally, these fields if `get_proposer_head` and `should_override_forkchoice_update` features are implemented: @@ -199,6 +203,10 @@ For example: proposer_boost_root: '0xdaa1d49d57594ced0c35688a6da133abb086d191a2ebdfd736fad95299325aeb' get_proposer_head: '0xdaa1d49d57594ced0c35688a6da133abb086d191a2ebdfd736fad95299325aeb' should_override_forkchoice_update: {validator_is_connected: false, result: false} + viable_for_head_roots_and_weights: [ + {root: '0x533290b6f44d31c925acd08dfc8448624979d48c40b877d4e6714648866c9ddb', weight: 192000000000}, + {root: '0x5cfb9d9099cdf1d8ab68ce96cdae9f0fa6eef16914a01070580dfdc1d2d59ec3', weight: 544000000000} + ] ``` *Note*: Each `checks` step may include one or multiple items. Each item has to be checked against the current store. diff --git a/tests/generators/fork_choice_generated/README.md b/tests/generators/fork_choice_generated/README.md new file mode 100644 index 0000000000..39d9637cfc --- /dev/null +++ b/tests/generators/fork_choice_generated/README.md @@ -0,0 +1,53 @@ +# Fork choice compliance test generator + +Fork Choice test generator intended to produce tests to validate conformance to the specs of various Fork Choice implementations. + +Implementation of the approach described in the [Fork Choice compliance testing framework](https://hackmd.io/@ericsson49/fork-choice-implementation-vs-spec-testing). + +Preliminary research has been also performed in this [repo](https://github.com/txrx-research/fork_choice_test_generation/tree/main). + +To simplfy adoption of the tests, we follow the test format described in the [fork choice test formats documentation](../../formats/fork_choice/README.md), with a minor exception (new check added). + +This work was supported by a grant from the Ethereum Foundation. + +# Pre-requisites + +Install requirements (preferrably, in a dedicated Python environment) + +``` +> pip install -r requirements.txt +``` + +In order to run tests, install `tqdm` additionally. +``` +> pip install tqdm +``` + +# Generating tests + +``` +> python test_gen.py -o ${test_dir} --fc-gen-config ${config_dir}/test_gen.yaml +``` + +There are three configurations in the repo: [tiny](tiny/), [small](small/) and [standard](standard/). + +# Running tests + +Install `tqdm` library (to show progress) +``` +> pip install tqdm +``` + +and then +``` +> python test_run.py -i ${test_dir} +``` + +# Generating configurations + +Files in [tiny](tiny/), [small](small/) and [standard](standard/) are generated with [generate_test_instances.py](generate_test_instances.py), e.g. +``` +> python generate_test_instances.py +``` + +But one normally doesn't need to generate them. diff --git a/tests/generators/fork_choice_generated/generate_test_instances.py b/tests/generators/fork_choice_generated/generate_test_instances.py new file mode 100644 index 0000000000..3846719cf5 --- /dev/null +++ b/tests/generators/fork_choice_generated/generate_test_instances.py @@ -0,0 +1,295 @@ +from dataclasses import dataclass, field +from itertools import product +from typing import Iterable +from toolz.dicttoolz import merge +from minizinc import Instance, Model, Solver +from ruamel.yaml import YAML +from typing_extensions import TypedDict + + +def solve_sm_links(anchor_epoch: int, number_of_epochs: int, number_of_links: int, number_of_solutions: int): + sm_links = Model('./model/minizinc/SM_links.mzn') + solver = Solver.lookup("gecode") + instance = Instance(solver, sm_links) + instance['AE'] = anchor_epoch # anchor epoch + instance['NE'] = number_of_epochs # number of epochs, starting from AE + instance['NL'] = number_of_links # number of super-majority links + + assert number_of_solutions is None + solutions = instance.solve(all_solutions=True) + + for i in range(len(solutions)): + yield {'sm_links': list(zip(solutions[i, 'sources'], solutions[i, 'targets']))} + + +def generate_sm_links(params): + anchor_epoch = params['anchor_epoch'] + number_of_epochs = params['number_of_epochs'] + number_of_links = params['number_of_links'] + number_of_solutions = params.get('number_of_solutions') + yield from solve_sm_links(anchor_epoch, number_of_epochs, number_of_links, number_of_solutions) + + +def solve_block_tree(number_of_blocks: int, + max_children: int, + number_of_solutions: int) -> Iterable[dict]: + model = Model('./model/minizinc/Block_tree.mzn') + solver = Solver.lookup("gecode") + instance = Instance(solver, model) + instance['NB'] = number_of_blocks + instance['MC'] = max_children + + if number_of_solutions is None: + solutions = instance.solve(all_solutions=True) + else: + solutions = instance.solve(nr_solutions=number_of_solutions) + + return [{'block_parents': s.parent} for s in solutions] + + +def generate_block_tree(params) -> Iterable[dict]: + number_of_blocks = params['number_of_blocks'] + max_children = params['max_children'] + number_of_solutions = params.get('number_of_solutions') + yield from solve_block_tree(number_of_blocks, max_children, number_of_solutions) + + +def solve_block_cover(anchor_epoch: int, + store_justified_epoch_equal_zero: bool, + block_voting_source_epoch_equal_store_justified_epoch: bool, + block_voting_source_epoch_plus_two_greater_or_equal_current_epoch: bool, + block_is_leaf: bool, + number_of_solutions: int): + block_cover3 = Model('./model/minizinc/Block_cover3.mzn') + solver = Solver.lookup("gecode") + instance = Instance(solver, block_cover3) + instance['AE'] = anchor_epoch + instance['store_je_eq_zero'] = store_justified_epoch_equal_zero + instance['block_vse_eq_store_je'] = block_voting_source_epoch_equal_store_justified_epoch + instance['block_vse_plus_two_ge_curr_e'] = block_voting_source_epoch_plus_two_greater_or_equal_current_epoch + instance['block_is_leaf'] = block_is_leaf + + assert number_of_solutions is not None + result = instance.solve(nr_solutions=number_of_solutions) + + if anchor_epoch == 0 and not store_justified_epoch_equal_zero: + return + + for s in result.solution: + max_block = s.max_block + yield {'block_epochs': s.es[:max_block + 1], + 'parents': s.parents[:max_block + 1], + 'previous_justifications': s.prevs[:max_block + 1], + 'current_justifications': s.currs[:max_block + 1], + 'current_epoch': s.curr_e, + 'store_justified_epoch': s.store_je, + 'target_block': s.target_block, + 'predicates': { + 'store_je_eq_zero': store_justified_epoch_equal_zero, + 'block_vse_eq_store_je': block_voting_source_epoch_equal_store_justified_epoch, + 'block_vse_plus_two_ge_curr_e': block_voting_source_epoch_plus_two_greater_or_equal_current_epoch, + 'block_is_leaf': block_is_leaf + }} + + +def generate_block_cover(params): + anchor_epoch = params['anchor_epoch'] + number_of_solutions = params.get('number_of_solutions', 1) + + for ps in product(*([(True, False)] * 4)): + yield from solve_block_cover(anchor_epoch, *ps, number_of_solutions) + + +# models = { +# 'sm_links': ModelKind('SMLinks', './model/minizinc/SM_links.mzn', {'AE': int, 'NE': int, 'NL': int}), +# 'block_cover': ModelKind('BlockCover', './model/minizinc/Block_cover3.mzn', +# { +# 'AE': int, +# 'store_je_eq_zero': bool, +# 'block_vse_eq_store_je': bool, +# 'block_vse_plus_two_ge_curr_e': bool, +# 'block_is_leaf': bool, +# 'block_is_justified_descendant': bool +# }) +# } + +gen_params = { + ################### + # tiny instances # + ################### + + 'block_tree_tree_tiny': { + 'out_path': 'tiny/block_tree_tree.yaml', + 'models': ['sm_link', 'block_tree'], + 'params': [ + ({'anchor_epoch': 0, 'number_of_epochs': 4, 'number_of_links': 3}, {'number_of_blocks': 8, 'max_children': 2, 'number_of_solutions': 3}), + ([{'sm_links': [[0, 1], [0, 2], [2, 3], [3, 4]]}], {'number_of_blocks': 16, 'max_children': 2, 'number_of_solutions': 3}), + ] + }, + 'block_tree_other_tiny': { + 'out_path': 'tiny/block_tree_other.yaml', + 'models': ['sm_link', 'block_tree'], + 'params': [ + ([{'sm_links': [[0, 1], [0, 2], [2, 3], [3, 4]]}], {'number_of_blocks': 12, 'max_children': 2, 'number_of_solutions': 3}), + ] + }, + 'block_cover_tiny': { + 'out_path': 'tiny/block_cover.yaml', + 'models': ['block_cover'], + 'params': [ + ({'anchor_epoch': 0, 'number_of_solutions': 1},), + ({'anchor_epoch': 2, 'number_of_solutions': 1},), + ] + }, + + ################### + # small instances # + ################### + + 'block_tree_tree_small': { + 'out_path': 'small/block_tree_tree.yaml', + 'models': ['sm_link', 'block_tree'], + 'params': [ + ({'anchor_epoch': 0, 'number_of_epochs': 5, 'number_of_links': 3}, {'number_of_blocks': 16, 'max_children': 2, 'number_of_solutions': 2}), + ([{'sm_links': [[0, 1], [0, 2], [2, 3], [3, 4]]}], {'number_of_blocks': 5, 'max_children': 3, 'number_of_solutions': None}), + ([{'sm_links': [[0, 1], [0, 2], [2, 3], [3, 4]]}], {'number_of_blocks': 12, 'max_children': 2, 'number_of_solutions': 73}), + ] + }, + 'block_tree_tree_small_2': { + 'out_path': 'small/block_tree_tree_2.yaml', + 'models': ['sm_link', 'block_tree'], + 'params': [ + ({'anchor_epoch': 0, 'number_of_epochs': 6, 'number_of_links': 4}, {'number_of_blocks': 16, 'max_children': 2, 'number_of_solutions': 2}), + ([{'sm_links': [[0, 1], [0, 2], [2, 3], [3, 4]]}], {'number_of_blocks': 6, 'max_children': 4, 'number_of_solutions': None}), + ([{'sm_links': [[0, 1], [0, 2], [2, 3], [3, 4]]}], {'number_of_blocks': 12, 'max_children': 2, 'number_of_solutions': 283}), + ] + }, + 'block_tree_other_small': { + 'out_path': 'small/block_tree_other.yaml', + 'models': ['sm_link', 'block_tree'], + 'params': [ + ([{'sm_links': [[0, 1], [0, 2], [2, 3], [3, 4]]}], {'number_of_blocks': 12, 'max_children': 2, 'number_of_solutions': 4}), + ] + }, + 'block_cover_small': { + 'out_path': 'small/block_cover.yaml', + 'models': ['block_cover'], + 'params': [ + ({'anchor_epoch': 0, 'number_of_solutions': 2},), + ({'anchor_epoch': 2, 'number_of_solutions': 2},), + ] + }, + + ###################### + # standard instances # + ###################### + + 'block_tree_tree': { + 'out_path': 'standard/block_tree_tree.yaml', + 'models': ['sm_link', 'block_tree'], + 'params': [ + ({'anchor_epoch': 0, 'number_of_epochs': 6, 'number_of_links': 4}, {'number_of_blocks': 16, 'max_children': 2, 'number_of_solutions': 5}), + ([{'sm_links': [[0, 1], [0, 2], [2, 3], [3, 4]]}], {'number_of_blocks': 6, 'max_children': 4, 'number_of_solutions': None}), + ([{'sm_links': [[0, 1], [0, 2], [2, 3], [3, 4]]}], {'number_of_blocks': 7, 'max_children': 2, 'number_of_solutions': None}), + ([{'sm_links': [[0, 1], [0, 2], [2, 3], [3, 4]]}], {'number_of_blocks': 16, 'max_children': 2, 'number_of_solutions': 358}), + ] + }, + 'block_tree_tree_2': { + 'out_path': 'standard/block_tree_tree_2.yaml', + 'models': ['sm_link', 'block_tree'], + 'params': [ + ({'anchor_epoch': 0, 'number_of_epochs': 6, 'number_of_links': 4}, {'number_of_blocks': 16, 'max_children': 2, 'number_of_solutions': 5}), + ([{'sm_links': [[0, 1], [0, 2], [2, 3], [3, 4]]}], {'number_of_blocks': 6, 'max_children': 4, 'number_of_solutions': None}), + ([{'sm_links': [[0, 1], [0, 2], [2, 3], [3, 4]]}], {'number_of_blocks': 7, 'max_children': 3, 'number_of_solutions': None}), + ([{'sm_links': [[0, 1], [0, 2], [2, 3], [3, 4]]}], {'number_of_blocks': 16, 'max_children': 2, 'number_of_solutions': 3101}), + ] + }, + 'block_tree_other': { + 'out_path': 'standard/block_tree_other.yaml', + 'models': ['sm_link', 'block_tree'], + 'params': [ + ([{'sm_links': [[0, 1], [0, 2], [2, 3], [3, 4]]}], {'number_of_blocks': 12, 'max_children': 2, 'number_of_solutions': 8}), + ] + }, + 'block_cover': { + 'out_path': 'standard/block_cover.yaml', + 'models': ['block_cover'], + 'params': [ + ({'anchor_epoch': 0, 'number_of_solutions': 5},), + ({'anchor_epoch': 2, 'number_of_solutions': 5},), + ] + }, + + + ############# + # old stuff # + ############# + + # 'attester_slashings_test': { + # 'out_path': 'attester_slashings.yaml', + # 'models': ['sm_link', 'block_tree'], + # 'params': [ + # ([{'sm_links': [[0, 1], [0, 2], [2, 3], [3, 4]]}], {'number_of_blocks': 16, 'max_children': 3, 'number_of_solutions': 4}), + # ({'anchor_epoch': 0, 'number_of_epochs': 4, 'number_of_links': 3}, {'number_of_blocks': 4, 'max_children': 3, 'number_of_solutions': 4}), + # ({'anchor_epoch': 0, 'number_of_epochs': 5, 'number_of_links': 4}, {'number_of_blocks': 4, 'max_children': 3, 'number_of_solutions': 4}), + # ] + # }, + # 'invalid_messages_test': { + # 'out_path': 'invalid_messages.yaml', + # 'models': ['sm_link', 'block_tree'], + # 'params': [ + # ([{'sm_links': [[0, 1], [0, 2], [2, 3], [3, 4]]}], {'number_of_blocks': 16, 'max_children': 3, 'number_of_solutions': 4}), + # ({'anchor_epoch': 0, 'number_of_epochs': 4, 'number_of_links': 3}, {'number_of_blocks': 4, 'max_children': 3, 'number_of_solutions': 4}), + # ({'anchor_epoch': 0, 'number_of_epochs': 5, 'number_of_links': 4}, {'number_of_blocks': 4, 'max_children': 3, 'number_of_solutions': 4}), + # ] + # }, + # 'block_cover_1': { + # 'out_path': 'block_cover_1.yaml', + # 'models': ['block_cover'], + # 'params': [ + # ({'anchor_epoch': 0, 'number_of_solutions': 1},), + # ({'anchor_epoch': 2, 'number_of_solutions': 1},), + # ] + # }, + # 'block_cover_100': { + # 'out_path': 'block_cover_100.yaml', + # 'models': ['block_cover'], + # 'params': [ + # ({'anchor_epoch': 0, 'number_of_solutions': 100},), + # ({'anchor_epoch': 2, 'number_of_solutions': 100},), + # ] + # } +} + + +if __name__ == '__main__': + yaml = YAML(typ='safe') + sm_links = [] + + for model_name, parameters in gen_params.items(): + print(f'processing {model_name}') + out_path = parameters['out_path'] + models = parameters['models'] + solutions = [] + for params in parameters['params']: + model_solutions = [] + for model, mod_params in zip(models, params): + print(f' model: {model}') + print(f' parameters: {mod_params}') + if isinstance(mod_params, list): + model_solutions.append(mod_params) + elif isinstance(mod_params, dict): + if model == 'sm_link': + model_solutions.append(list(generate_sm_links(mod_params))) + elif model == 'block_tree': + model_solutions.append(list(generate_block_tree(mod_params))) + elif model == 'block_cover': + model_solutions.append(list(generate_block_cover(mod_params))) + else: + print('todo', model, mod_params) + else: + assert False + results = [merge(*sol) for sol in product(*model_solutions)] + solutions.extend(results) + with open(out_path, 'w') as f: + yaml.dump(solutions, f) diff --git a/tests/generators/fork_choice_generated/instance_generator.py b/tests/generators/fork_choice_generated/instance_generator.py new file mode 100644 index 0000000000..f9dd1fb335 --- /dev/null +++ b/tests/generators/fork_choice_generated/instance_generator.py @@ -0,0 +1,267 @@ +from eth2spec.test.helpers.constants import ALTAIR, DENEB +from eth2spec.gen_helpers.gen_base import gen_runner +from eth2spec.test.helpers.constants import MINIMAL, MAINNET +from itertools import product +from toolz.dicttoolz import merge +from typing import Iterable, Callable +from minizinc import Instance, Model, Solver +from ruamel.yaml import YAML +from test_provider import GENERATOR_NAME, create_providers + + +forks = [DENEB] +presets = [MINIMAL] + + +def _find_sm_link_solutions(anchor_epoch: int, + number_of_epochs: int, + number_of_links: int) -> Iterable[Iterable[tuple]]: + # Dependencies: + # 1. Install minizinc binary + # https://www.minizinc.org/doc-2.5.5/en/installation_detailed_linux.html + # 2. Install minizinc python lib + # pip install minizinc + # 3. Install and confifure gecode solver: + # https://www.minizinc.org/doc-2.5.5/en/installation_detailed_linux.html#gecode + sm_links = Model('./model/minizinc/SM_links.mzn') + solver = Solver.lookup("gecode") + instance = Instance(solver, sm_links) + instance['AE'] = anchor_epoch # anchor epoch + instance['NE'] = number_of_epochs # number of epochs, starting from AE + instance['NL'] = number_of_links # number of super-majority links + + solutions = instance.solve(all_solutions=True) + for i in range(len(solutions)): + yield {'sm_links': list(zip(solutions[i, 'sources'], solutions[i, 'targets']))} + + +def _find_block_tree_solutions(number_of_blocks: int, + max_children: int, + number_of_solutions: int) -> Iterable[dict]: + model = Model('./model/minizinc/Block_tree.mzn') + solver = Solver.lookup("gecode") + instance = Instance(solver, model) + instance['NB'] = number_of_blocks + instance['MC'] = max_children + + solutions = instance.solve(nr_solutions=number_of_solutions) + return [{'block_parents': s.parent} for s in solutions] + + +def _load_block_tree_instances(instance_path: str) -> Iterable[dict]: + yaml = YAML(typ='safe') + solutions = yaml.load(open(instance_path, 'r')) + return solutions + + +def _find_block_cover_model_solutions(anchor_epoch: int, + store_justified_epoch_equal_zero: bool, + block_voting_source_epoch_equal_store_justified_epoch: bool, + block_voting_source_epoch_plus_two_greater_or_equal_current_epoch: bool, + block_is_leaf: bool, + nr_solutions: int=5) -> []: + block_cover3 = Model('./model/minizinc/Block_cover3.mzn') + solver = Solver.lookup("gecode") + instance = Instance(solver, block_cover3) + instance['AE'] = anchor_epoch + instance['store_je_eq_zero'] = store_justified_epoch_equal_zero + instance['block_vse_eq_store_je'] = block_voting_source_epoch_equal_store_justified_epoch + instance['block_vse_plus_two_ge_curr_e'] = block_voting_source_epoch_plus_two_greater_or_equal_current_epoch + instance['block_is_leaf'] = block_is_leaf + + result = instance.solve(nr_solutions=nr_solutions) + + output = [] + for s in result.solution: + max_block = s.max_block + output.append({'block_epochs': s.es[:max_block + 1], + 'parents': s.parents[:max_block + 1], + 'previous_justifications': s.prevs[:max_block + 1], + 'current_justifications': s.currs[:max_block + 1], + 'current_epoch': s.curr_e, + 'store_justified_epoch': s.store_je, + 'target_block': s.target_block, + 'predicates': { + 'store_je_eq_zero': store_justified_epoch_equal_zero, + 'block_vse_eq_store_je': block_voting_source_epoch_equal_store_justified_epoch, + 'block_vse_plus_two_ge_curr_e': block_voting_source_epoch_plus_two_greater_or_equal_current_epoch, + 'block_is_leaf': block_is_leaf + }}) + + return output + + +def _generate_block_cover_model_solutions(anchor_epoch: int, nr_solutions: int=5, debug=False): + solutions = [] + + for store_je_eq_zero in [True, False]: + for block_vse_eq_store_je in [True, False]: + for block_vse_plus_two_ge_curr_e in [True, False]: + for block_is_leaf in [True, False]: + if store_je_eq_zero and not block_vse_eq_store_je: + continue + if anchor_epoch == 0 and not store_je_eq_zero: + continue + results = _find_block_cover_model_solutions( + anchor_epoch=0 if store_je_eq_zero else anchor_epoch, + store_justified_epoch_equal_zero=store_je_eq_zero, + block_voting_source_epoch_equal_store_justified_epoch=block_vse_eq_store_je, + block_voting_source_epoch_plus_two_greater_or_equal_current_epoch=block_vse_plus_two_ge_curr_e, + block_is_leaf=block_is_leaf, + nr_solutions=nr_solutions) + if debug: + print('\n\n') + print(['store_je_eq_zero=' + str(store_je_eq_zero), + 'block_vse_eq_store_je=' + str(block_vse_eq_store_je), + 'block_vse_plus_two_ge_curr_e=' + str(block_vse_plus_two_ge_curr_e), + 'block_is_leaf=' + str(block_is_leaf)]) + for r in results: + print(r) + + solutions.extend(results) + + return solutions + + +def _load_block_cover_instances(instance_path: str): + yaml = YAML(typ='safe') + solutions = yaml.load(open(instance_path, 'r')) + return solutions + + +if __name__ == "__main__": + arg_parser = gen_runner.create_arg_parser(GENERATOR_NAME) + + arg_parser.add_argument( + '--fc-gen-debug', + dest='fc_gen_debug', + action='store_true', + default=False, + required=False, + help='If set provides debug output and enable additional checks for generated chains', + ) + arg_parser.add_argument( + '--fc-gen-test-kind', + dest='fc_gen_test_kind', + type=str, + required=True, + help='Test kind: block_tree or block_cover' + ) + arg_parser.add_argument( + '--fc-gen-seed', + dest='fc_gen_seed', + default=1, + type=int, + required=False, + help='Provides randomizer with initial seed' + ) + arg_parser.add_argument( + '--fc-gen-variations', + dest='fc_gen_variations', + default=1, + type=int, + required=False, + help='Number of random variations per each solution' + ) + arg_parser.add_argument( + '--fc-gen-anchor-epoch', + dest='fc_gen_anchor_epoch', + default=0, + type=int, + required=False, + help='Anchor epoch' + ) + arg_parser.add_argument( + '--fc-gen-epochs', + dest='fc_gen_epochs', + default=2, + type=int, + required=False, + help='Number of epochs beyond the anchor epoch' + ) + arg_parser.add_argument( + '--fc-gen-links', + dest='fc_gen_links', + default=1, + type=int, + required=False, + help='Number of super majority links per solution' + ) + arg_parser.add_argument( + '--fc-gen-mutations', + dest='fc_gen_mutations', + default=0, + type=int, + required=False, + help='Number of mutations per base test case' + ) + arg_parser.add_argument( + '--fc-gen-attester-slashings', + dest='fc_gen_attester_slashings', + default=False, + type=bool, + required=False, + help='Pass with_attester_slashings flag' + ) + arg_parser.add_argument( + '--fc-gen-invalid-messages', + dest='fc_gen_invalid_messages', + default=False, + type=bool, + required=False, + help='Pass with_invalid_messages flag' + ) + arg_parser.add_argument( + '--fc-gen-instances-path', + dest='fc_gen_instances_path', + default=None, + type=str, + required=False, + help='Path to a file with pre-generated instances' + ) + arg_parser.add_argument( + '--fc-gen-nr-solutions', + dest='fc_gen_nr_solutions', + default=5, + type=int, + required=False, + help='Number of solutions per MiniZinc query' + ) + + args = arg_parser.parse_args() + + if args.fc_gen_test_kind == 'block_tree': + if args.fc_gen_instances_path is not None: + solutions = _load_block_tree_instances(args.fc_gen_instances_path) + else: + sm_link_solutions = _find_sm_link_solutions(args.fc_gen_anchor_epoch, args.fc_gen_epochs, args.fc_gen_links) + block_tree_solutions = _find_block_tree_solutions(16, 3, 3) + solutions = [merge(*sols) for sols in product(sm_link_solutions, block_tree_solutions)] + + with_attester_slashings, with_invalid_messages = args.fc_gen_attester_slashings, args.fc_gen_invalid_messages + if not with_attester_slashings and not with_invalid_messages: + test_name = 'block_tree' + test_kind = 'block_tree_test' + elif with_attester_slashings and not with_invalid_messages: + test_name = 'attester_slashings' + test_kind = 'attester_slashing_test' + elif with_attester_slashings and with_invalid_messages: + test_name = 'invalid_messages' + test_kind = 'invalid_message_test' + else: + test_name = 'attester_slashings_and_invalid_messages' + test_kind = 'attestet_slashing_and_invalid_message_test' + elif args.fc_gen_test_kind == 'block_cover': + if args.fc_gen_instances_path is not None: + solutions = _load_block_cover_instances(args.fc_gen_instances_path) + else: + solutions = _generate_block_cover_model_solutions(args.fc_gen_anchor_epoch, args.fc_gen_nr_solutions, args.fc_gen_debug) + + test_name = 'block_cover' + test_kind = 'block_cover_test' + else: + raise ValueError(f'Unsupported test kind: {args.fc_gen_test_kind}') + + providers = create_providers(test_name, forks, presets, args.fc_gen_debug, args.fc_gen_seed, + solutions, args.fc_gen_variations, args.fc_gen_mutations, test_kind) + gen_runner.run_generator(GENERATOR_NAME, providers, arg_parser) diff --git a/tests/generators/fork_choice_generated/instantiators/block_cover.py b/tests/generators/fork_choice_generated/instantiators/block_cover.py new file mode 100644 index 0000000000..4546ceb9a8 --- /dev/null +++ b/tests/generators/fork_choice_generated/instantiators/block_cover.py @@ -0,0 +1,286 @@ +import random +from eth2spec.test.context import ( + spec_state_test, + with_altair_and_later, +) +from eth2spec.test.helpers.state import ( + transition_to, + next_slot, +) +from .helpers import ( + ProtocolMessage, + FCTestData, + BranchTip, +) +from .helpers import ( + advance_state_to_anchor_epoch, + produce_block, + attest_to_slot, + yield_fork_choice_test_case, +) +from eth2spec.utils import bls + +def _should_justify_epoch(parents, current_justifications, previous_justifications, block) -> bool: + if current_justifications[block]: + return True + + # Check if any child of the block justifies the epoch + for c in (b for b, p in enumerate(parents) if p == block): + if previous_justifications[c]: + return True + + return False + + +def _generate_filter_block_tree(spec, genesis_state, block_epochs, parents, previous_justifications, + current_justifications, rnd: random.Random, debug) -> ([], []): + JUSTIFYING_SLOT = 2 * spec.SLOTS_PER_EPOCH // 3 + 1 + JUSTIFYING_SLOT_COUNT = spec.SLOTS_PER_EPOCH - JUSTIFYING_SLOT + + anchor_epoch = block_epochs[0] + + # Run constraint checks before starting to generate blocks + for epoch in range(anchor_epoch + 1, max(block_epochs) + 1): + current_blocks = [i for i, e in enumerate(block_epochs) if e == epoch] + assert len(current_blocks) <= spec.SLOTS_PER_EPOCH, 'Number of blocks does not fit into an epoch=' + str(epoch) + + justifying_blocks = [b for b in current_blocks if _should_justify_epoch( + parents, current_justifications, previous_justifications, b)] + + # There should be enough slots to propose all blocks that are required to justify the epoch + assert len(justifying_blocks) <= JUSTIFYING_SLOT_COUNT, \ + 'Not enough slots to accommodate blocks justifying epoch=' + str(epoch) + + signed_blocks, anchor_tip = advance_state_to_anchor_epoch(spec, genesis_state, anchor_epoch, debug) + + block_tips = [None for _ in range(0, len(block_epochs))] + # Initialize with the anchor block + block_tips[0] = anchor_tip + + for epoch in range(anchor_epoch + 1, max(block_epochs) + 1): + current_blocks = [i for i, e in enumerate(block_epochs) if e == epoch] + if len(current_blocks) == 0: + continue + + # Case 2. Blocks are from disjoint subtrees -- not supported yet + assert len( + set([a for i, a in enumerate(parents) if i in current_blocks])) == 1, 'Disjoint trees are not supported' + + # Case 1. Blocks have common ancestor + a = parents[current_blocks[0]] + ancestor_tip = block_tips[a].copy() + + state = ancestor_tip.beacon_state + attestations = ancestor_tip.attestations + + justifying_blocks = [b for b in current_blocks if _should_justify_epoch( + parents, current_justifications, previous_justifications, b)] + + common_prefix_len = min(JUSTIFYING_SLOT, spec.SLOTS_PER_EPOCH - len(current_blocks)) + threshold_slot = spec.compute_start_slot_at_epoch(epoch) + common_prefix_len + + # Build the chain up to but excluding a block that will justify current checkpoint + while (state.slot < threshold_slot): + # Do not include attestations into blocks + if (state.slot < spec.compute_start_slot_at_epoch(epoch)): + new_block, state, _, _ = produce_block(spec, state, []) + signed_blocks.append(new_block) + else: + # Prevent previous epoch from being accidentally justified + # by filtering out previous epoch attestations + curr_epoch_attestations = [a for a in attestations if + epoch == spec.compute_epoch_at_slot(a.data.slot)] + other_attestations = [a for a in attestations if a not in curr_epoch_attestations] + new_block, state, curr_epoch_attestations, _ = produce_block(spec, state, curr_epoch_attestations) + attestations = other_attestations + curr_epoch_attestations + signed_blocks.append(new_block) + + # Attest + curr_slot_attestations = attest_to_slot(spec, state, state.slot) + attestations = curr_slot_attestations + attestations + + # Next slot + next_slot(spec, state) + + common_state = state + + # Assumption: one block is enough to satisfy previous_justifications[b] and current_justifications[b], + # i.e. block capacity is enough to accommodate attestations to justify previus and current epoch checkpoints + # if that needed. Considering that most of attestations were already included into the common chain prefix, + # we assume it is possible + empty_slot_count = spec.SLOTS_PER_EPOCH - common_prefix_len - len(current_blocks) + block_distribution = current_blocks.copy() + [-1 for _ in range(0, empty_slot_count)] + + # Randomly distribute blocks across slots + rnd.shuffle(block_distribution) + + # Move all blocks that require to justify current epoch to the end to increase the chance of justification + block_distribution = [b for b in block_distribution if b not in justifying_blocks] + block_distribution = block_distribution + justifying_blocks + + for index, block in enumerate(block_distribution): + slot = threshold_slot + index + state = common_state.copy() + + # Advance state to the slot + if state.slot < slot: + transition_to(spec, state, slot) + + # Propose a block if slot isn't empty + block_attestations = [] + if block > -1: + previous_epoch_attestations = [a for a in attestations if + epoch == spec.compute_epoch_at_slot(a.data.slot) + 1] + current_epoch_attestations = [a for a in attestations if + epoch == spec.compute_epoch_at_slot(a.data.slot)] + if (previous_justifications[block]): + block_attestations = block_attestations + previous_epoch_attestations + if (current_justifications[block]): + block_attestations = block_attestations + current_epoch_attestations + + # Propose block + new_block, state, _, _ = produce_block(spec, state, block_attestations) + signed_blocks.append(new_block) + + # Attest + # TODO pick a random tip to make attestation with if the slot is empty + curr_slot_attestations = attest_to_slot(spec, state, state.slot) + attestations = curr_slot_attestations + attestations + + # Next slot + next_slot(spec, state) + + if block > -1: + not_included_attestations = [a for a in attestations if a not in block_attestations] + + check_up_state = state.copy() + spec.process_justification_and_finalization(check_up_state) + + if current_justifications[block]: + assert check_up_state.current_justified_checkpoint.epoch == epoch, 'Unexpected current_jusitified_checkpoint.epoch: ' + str( + check_up_state.current_justified_checkpoint.epoch) + ' != ' + str(epoch) + elif previous_justifications[block]: + assert check_up_state.current_justified_checkpoint.epoch + 1 == epoch, 'Unexpected current_jusitified_checkpoint.epoch: ' + str( + check_up_state.current_justified_checkpoint.epoch) + ' != ' + str(epoch - 1) + + block_tips[block] = BranchTip(state, not_included_attestations, [*range(0, len(state.validators))], + check_up_state.current_justified_checkpoint) + + return signed_blocks, block_tips + + +def gen_block_cover_test_data(spec, state, model_params, debug, seed) -> (FCTestData, object): + anchor_state = state + anchor_block = spec.BeaconBlock(state_root=anchor_state.hash_tree_root()) + + print('\nseed:', seed) + print('model_params:', str(model_params)) + + block_epochs = model_params['block_epochs'] + parents = model_params['parents'] + previous_justifications = model_params['previous_justifications'] + current_justifications = model_params['current_justifications'] + + store_justified_epoch = model_params['store_justified_epoch'] + target_block = model_params['target_block'] + + anchor_epoch = block_epochs[0] + + # Ensure that there is no attempt to justify GENESIS_EPOCH + 1 as it is not supported by the protocol + assert store_justified_epoch != spec.GENESIS_EPOCH + 1, 'Justification of epoch 1 is not supported by the protocol' + + # Ensure that epoch(block) == epoch(parent) + 1 + for b in range(1, len(block_epochs)): + assert block_epochs[b] == block_epochs[parents[b]] + 1, 'epoch(' + str(b) + ') != epoch(' + str( + parents[b]) + ') + 1, block_epochs=' + str(block_epochs) + ', parents=' + str(parents) + + # Ensure that a descendant doesn't attempt to justify the previous epoch checkpoint + # if it has already been justified by its ancestor + for b in range(1, len(block_epochs)): + if previous_justifications[b]: + a = parents[b] + assert not current_justifications[a], str(b) + ' attempts to justify already justified epoch' + + rnd = random.Random(seed) + signed_blocks, post_block_tips = _generate_filter_block_tree(spec, + state, + block_epochs, + parents, + previous_justifications, + current_justifications, + rnd, + debug) + + # Meta data + meta = { + 'seed': seed, + 'model_params': model_params, + 'bls_setting': 0 if bls.bls_active else 2, + } + + blocks = [ProtocolMessage(block) for block in signed_blocks] + + current_epoch_slot = spec.compute_start_slot_at_epoch(model_params['current_epoch']) + current_epoch_time = state.genesis_time + current_epoch_slot * spec.config.SECONDS_PER_SLOT + + test_data = FCTestData(meta, anchor_block, anchor_state, blocks, store_final_time=current_epoch_time) + target_block_root = spec.hash_tree_root(post_block_tips[target_block].beacon_state.latest_block_header) + + return test_data, target_block_root + + +def run_sanity_checks(spec, store, model_params, target_block_root): + current_epoch = spec.get_current_store_epoch(store) + # Ensure the epoch is correct + assert current_epoch == model_params['current_epoch'], str(current_epoch) + ' != ' + str( + model_params['current_epoch']) + # Ensure the store.justified_checkpoint.epoch is as expected + assert store.justified_checkpoint.epoch == model_params['store_justified_epoch'] + + # Check predicates + predicates = model_params['predicates'] + if predicates['store_je_eq_zero']: + assert store.justified_checkpoint.epoch == spec.GENESIS_EPOCH, "store_je_eq_zero not satisfied" + + if predicates['block_is_leaf']: + assert not any( + b for b in store.blocks.values() if b.parent_root == target_block_root), "block_is_leaf not satisfied" + else: + assert any( + b for b in store.blocks.values() if b.parent_root == target_block_root), "block_is_leaf not satisfied" + + voting_source = spec.get_voting_source(store, target_block_root) + if predicates['block_vse_eq_store_je']: + assert voting_source.epoch == store.justified_checkpoint.epoch, "block_vse_eq_store_je not satisfied" + else: + assert voting_source.epoch != store.justified_checkpoint.epoch, "block_vse_eq_store_je not satisfied" + + if predicates['block_vse_plus_two_ge_curr_e']: + assert voting_source.epoch + 2 >= current_epoch, "block_vse_plus_two_ge_curr_e not satisfied" + else: + assert voting_source.epoch + 2 < current_epoch, "block_vse_plus_two_ge_curr_e not satisfied" + + # Ensure the target block is in filtered blocks if it is a leaf and eligible + if (predicates['block_is_leaf'] + and (predicates['store_je_eq_zero'] + or predicates['block_vse_eq_store_je'] + or predicates['block_vse_plus_two_ge_curr_e'])): + assert target_block_root in spec.get_filtered_block_tree(store).keys() + + +@with_altair_and_later +@spec_state_test +def yield_block_cover_test_case(spec, state, model_params=None, debug=False, seed=1): + test_data, target_block_root = gen_block_cover_test_data(spec, state, model_params, debug, seed) + store = spec.get_forkchoice_store(test_data.anchor_state, test_data.anchor_block) + yield from yield_fork_choice_test_case(spec, store, test_data, debug) + # Run sanity checks against model params + run_sanity_checks(spec, store, model_params, target_block_root) + +@with_altair_and_later +@spec_state_test +def yield_block_cover_test_data(spec, state, model_params=None, debug=False, seed=1): + test_data, _ = gen_block_cover_test_data(spec, state, model_params, debug, seed) + yield 'test_data', test_data + # Run sanity checks against model params + # run_sanity_checks(spec, store, model_params, target_block_root) diff --git a/tests/generators/fork_choice_generated/instantiators/block_tree.py b/tests/generators/fork_choice_generated/instantiators/block_tree.py new file mode 100644 index 0000000000..ff82ad66c0 --- /dev/null +++ b/tests/generators/fork_choice_generated/instantiators/block_tree.py @@ -0,0 +1,615 @@ +import random +from eth2spec.test.context import ( + spec_state_test, + with_altair_and_later, +) +from eth2spec.test.helpers.attester_slashings import ( + get_valid_attester_slashing_by_indices, +) +from eth2spec.test.helpers.state import ( + transition_to, + next_slot, +) +from .helpers import ( + ProtocolMessage, + FCTestData, + BranchTip, +) +from .helpers import ( + advance_branch_to_next_epoch, + advance_state_to_anchor_epoch, + produce_block, + attest_to_slot, + yield_fork_choice_test_case, +) +from .debug_helpers import ( + attesters_in_block, + print_epoch, + print_block_tree, +) +from eth2spec.utils import bls + +MAX_JUSTIFICATION_RATE = 99 +MIN_JUSTIFICATION_RATE = 91 + +MAX_UNDERJUSTIFICATION_RATE = 65 +MIN_UNDERJUSTIFICATION_RATE = 55 + +EMPTY_SLOTS_RATE = 3 +MAX_TIPS_TO_ATTEST = 2 + +OFF_CHAIN_ATTESTATION_RATE = 10 +ON_CHAIN_ATTESTATION_RATE = 20 + +MAX_ATTESTER_SLASHINGS = 8 +ATTESTER_SLASHINGS_RATE = 8 +OFF_CHAIN_SLASHING_RATE = 33 +ON_CHAIN_SLASHING_RATE = 33 + +INVALID_MESSAGES_RATE = 5 + +class SmLink(tuple): + @property + def source(self): + return self[0] + + @property + def target(self): + return self[1] + + +def _justifying_participation_rate(rnd: random.Random): + """ + Should be high enough to ensure justification happens + """ + return rnd.randint(MIN_JUSTIFICATION_RATE, MAX_JUSTIFICATION_RATE) + + +def _under_justifying_participation_rate(rnd: random.Random): + return rnd.randint(MIN_UNDERJUSTIFICATION_RATE, MAX_UNDERJUSTIFICATION_RATE) + + +def _create_new_branch_tip(spec, branch_tips: dict[SmLink:BranchTip], sm_link: SmLink) -> BranchTip: + """ + Initialized a branch tip state for a new branch satisfying the given sm_link. + :return: a new branch tip. + """ + + # Find all forks with justified source + tips_with_justified_source = [s for s in branch_tips.values() + if s.eventually_justified_checkpoint.epoch == sm_link.source] + assert len(tips_with_justified_source) > 0 + + # Find and return the most adanced one + most_recent_tip = max(tips_with_justified_source, key=lambda s: s.beacon_state.slot) + return BranchTip(most_recent_tip.beacon_state.copy(), most_recent_tip.attestations.copy(), [], + most_recent_tip.eventually_justified_checkpoint) + + +def _sample_validator_partition(spec, state, epoch, participation_rate, rnd) -> []: + active_validator_indices = spec.get_active_validator_indices(state, epoch) + participants_count = len(active_validator_indices) * participation_rate // 100 + return rnd.sample(active_validator_indices, participants_count) + + +def _compute_validator_partitions(spec, branch_tips, current_links, current_epoch, rnd: random.Random) -> dict[ + SmLink:[int]]: + """ + Note: O(N) complex (N is a number of validators) and might be inefficient with large validator sets + + Uniformly distributes active validators between active forks specified by a given set of sm_links. + Handles two cases: + 1. Single active fork: + Randomly sample a single validator partition taking into account + whether the fork should have a justified checkpoint in the current epoch. + 2. Multiple active forks: + i. sample the majority partition if one of the forks is about to justify during the current epoch, + ii. run through a set of active validators and randomly select a fork for it, + do no consider validators that were sampled into the majority partition. + + Does not take into account validator's effective balance, based on assumption that the EB of every validator + is nearly the same. + + :return: [SmLink: participants] + """ + + justifying_links = [l for l in current_links if l.target == current_epoch] + + # Justifying conflicting checkpoints isn't supported + assert len(justifying_links) < 2 + justifying_link = justifying_links[0] if any(justifying_links) else None + + # Sanity check + for sm_link in current_links: + assert spec.get_current_epoch(branch_tips[sm_link].beacon_state) == current_epoch + + # Case when there is just one active fork + if len(current_links) == 1: + the_sm_link = current_links[0] + + if the_sm_link == justifying_link: + participation_rate = _justifying_participation_rate(rnd) + else: + participation_rate = _under_justifying_participation_rate(rnd) + + state = branch_tips[the_sm_link].beacon_state + participants = _sample_validator_partition(spec, state, current_epoch, participation_rate, rnd) + + return {the_sm_link: participants} + + # Cases with more than one active fork + participants = {l: [] for l in current_links} + + # Move the majority to the branch containing justification target + justifying_participants = [] + if justifying_link is not None: + state = branch_tips[justifying_link].beacon_state + justifying_participants = _sample_validator_partition(spec, + branch_tips[justifying_link].beacon_state, + current_epoch, + _justifying_participation_rate(rnd), + rnd) + + participants[justifying_link] = justifying_participants + + # Collect a set of active validator indexes across all forks + active_validator_per_branch = {} + all_active_validators = set() + for l in current_links: + state = branch_tips[l].beacon_state + active_validator_per_branch[l] = spec.get_active_validator_indices(state, current_epoch) + all_active_validators.update(active_validator_per_branch[l]) + + # Remove validators selected for justifying brach from the pool of active participants + all_active_validators = all_active_validators.difference(justifying_participants) + + # For each index: + # 1) Collect a set of branches where the validators is in active state (except for justifying branch) + # 2) Append the index to the list of participants for a randomly selected branch + for index in all_active_validators: + active_branches = [l for l in current_links if + index in active_validator_per_branch[l] and l not in justifying_links] + participants[tuple(rnd.choice(active_branches))].append(index) + + return participants + + +def _any_change_to_validator_partitions(spec, sm_links, current_epoch, anchor_epoch) -> bool: + """ + Returns ``true`` if validator partitions should be re-shuffled to advance branches in the current epoch: + 1. The first epoch after the anchor epoch always requires a new shuffling. + 2. Previous epoch has justified checkpoints. + Therefore, new supermajority links may need to be processed during the current epoch, + thus new block tree branches with new validator partitions may need to be created. + 3. Current epoch has justified checkpoint. + Therefore, the majority of validators must be moved to the justifying branch. + """ + assert current_epoch > anchor_epoch + + previous_epoch = current_epoch - 1 + + if previous_epoch == anchor_epoch: + return True + + for l in sm_links: + if l.target == current_epoch or l.target == previous_epoch: + return True + + return False + + +def _generate_sm_link_tree(spec, genesis_state, sm_links, rnd: random.Random, debug) -> ([], BranchTip): + """ + Generates a sequence of blocks satisfying a tree of supermajority links specified in the sm_links list, + i.e. a sequence of blocks with attestations required to create given supermajority links. + + The block generation strategy is to run through a span of epochs covered by the supermajority links + and for each epoch of the span apply the following steps: + 1. Obtain a list of supermajority links covering the epoch. + 2. Create a new block tree branch (fork) for every newly observed supermajority link. + 3. Randomly sample all active validators between a set of forks that are being advanced in the epoch. + Validator partitions are disjoint and are changing only at the epoch boundary. + If no new branches are created in the current epoch then partitions from the previous epoch will be used + to advahce the state of every fork to the next epoch. + 4. Advance every fork to the next epoch respecting a validator partition assigned to it in the current epoch. + Preserve attestations produced but not yet included on chain for potential inclusion in the next epoch. + 5. Justify required checkpoints by moving the majority of validators to the justifying fork, + this is taken into account by step (3). + + :return: Sequence of signed blocks oredered by a slot number. + """ + assert any(sm_links) + + # Find anchor epoch + anchor_epoch = min(sm_links, key=lambda l: l.source).source + + signed_blocks, anchor_tip = advance_state_to_anchor_epoch(spec, genesis_state, anchor_epoch, debug) + + # branch_tips hold the most recent state, validator partition and not included attestations for every fork + # Initialize branch tips with the anchor tip + anchor_link = SmLink((spec.GENESIS_EPOCH, anchor_epoch)) + branch_tips = {anchor_link: anchor_tip} + + highest_target_sm_link = max(sm_links, key=lambda l: l.target) + + # Finish at after the highest justified checkpoint + for current_epoch in range(anchor_epoch + 1, highest_target_sm_link.target + 1): + # Obtain sm links that span over the current epoch + current_epoch_sm_links = [l for l in sm_links if l.source < current_epoch <= l.target] + + # Initialize new forks + for l in (l for l in current_epoch_sm_links if branch_tips.get(l) is None): + new_branch_tip = _create_new_branch_tip(spec, branch_tips, l) + # Abort the test if any sm_links constraint appears to be unreachable + # because the justification of the source checkpoint hasn't been realized on chain yet + if l.target == current_epoch and new_branch_tip.beacon_state.current_justified_checkpoint.epoch < l.source: + return [], new_branch_tip + + branch_tips[l] = new_branch_tip + + # Reshuffle partitions if needed + if _any_change_to_validator_partitions(spec, sm_links, current_epoch, anchor_epoch): + partitions = _compute_validator_partitions(spec, branch_tips, current_epoch_sm_links, current_epoch, rnd) + for l in partitions.keys(): + old_tip_state = branch_tips[l] + new_tip_state = BranchTip(old_tip_state.beacon_state, old_tip_state.attestations, partitions[l], + old_tip_state.eventually_justified_checkpoint) + branch_tips[l] = new_tip_state + + # Debug checks + if debug: + print('\nepoch', str(current_epoch) + ':') + # Partitions are disjoint + for l1 in current_epoch_sm_links: + l1_participants = branch_tips[l1].participants + for l2 in current_epoch_sm_links: + if l1 != l2: + l2_participants = branch_tips[l2].participants + intersection = set(l1_participants).intersection(l2_participants) + assert len(intersection) == 0, \ + str(l1) + ' and ' + str(l2) + ' has common participants: ' + str(intersection) + + # Advance every branch taking into account attestations from past epochs and voting partitions + for sm_link in current_epoch_sm_links: + branch_tip = branch_tips[sm_link] + assert spec.get_current_epoch(branch_tip.beacon_state) == current_epoch, \ + 'Unexpected current_epoch(branch_tip.beacon_state): ' + str( + spec.get_current_epoch(branch_tip.beacon_state)) + ' != ' + str(current_epoch) + new_signed_blocks, new_branch_tip = advance_branch_to_next_epoch(spec, branch_tip) + + # Run sanity checks + post_state = new_branch_tip.beacon_state + assert spec.get_current_epoch(post_state) == current_epoch + 1, \ + 'Unexpected post_state epoch: ' + str(spec.get_current_epoch(post_state)) + ' != ' + str( + current_epoch + 1) + if sm_link.target == current_epoch: + assert post_state.previous_justified_checkpoint.epoch == sm_link.source, \ + 'Unexpected previous_justified_checkpoint.epoch: ' + str( + post_state.previous_justified_checkpoint.epoch) + ' != ' + str(sm_link.source) + assert new_branch_tip.eventually_justified_checkpoint.epoch == sm_link.target, \ + 'Unexpected eventually_justified_checkpoint.epoch: ' + str( + new_branch_tip.eventually_justified_checkpoint.epoch) + ' != ' + str(sm_link.target) + elif (sm_link.source != new_branch_tip.eventually_justified_checkpoint.epoch): + # Abort the test as the justification of the source checkpoint can't be realized on chain + # because of the lack of the block space + return [], new_branch_tip + + # If the fork won't be advanced in the future epochs + # ensure 1) all yet not included attestations are included on chain by advancing it to epoch N+1 + # 2) justification is realized by advancing it to epoch N+2 + is_fork_advanced_in_future = any((l for l in sm_links if l.source == sm_link.target)) + if sm_link.target == current_epoch and not is_fork_advanced_in_future: + advanced_branch_tip = new_branch_tip + + # Advance to N+1 if state.current_justified_checkpoint.epoch < eventually_justified_checkpoint.epoch + current_justified_epoch = new_branch_tip.beacon_state.current_justified_checkpoint.epoch + eventually_justified_epoch = new_branch_tip.eventually_justified_checkpoint.epoch + if current_justified_epoch < eventually_justified_epoch: + advanced_signed_blocks, advanced_branch_tip = advance_branch_to_next_epoch(spec, new_branch_tip, + enable_attesting=False) + new_signed_blocks = new_signed_blocks + advanced_signed_blocks + + # Build a block in the next epoch to justify the target on chain + state = advanced_branch_tip.beacon_state + while (spec.get_beacon_proposer_index(state) not in advanced_branch_tip.participants): + next_slot(spec, state) + + tip_block, _, _, _ = produce_block(spec, state, []) + new_signed_blocks.append(tip_block) + + assert state.current_justified_checkpoint.epoch == sm_link.target, \ + 'Unexpected state.current_justified_checkpoint: ' + str( + state.current_justified_checkpoint.epoch) + ' != ' + str(sm_link.target) + + # Debug output + if debug: + print('branch' + str(sm_link) + ':', + print_epoch(spec, branch_tips[sm_link].beacon_state, new_signed_blocks)) + print(' ', len(branch_tips[sm_link].participants), 'participants:', + new_branch_tip.participants) + print(' ', 'state.current_justified_checkpoint:', + '(epoch=' + str(post_state.current_justified_checkpoint.epoch) + + ', root=' + str(post_state.current_justified_checkpoint.root)[:6] + ')') + print(' ', 'eventually_justified_checkpoint:', + '(epoch=' + str(new_branch_tip.eventually_justified_checkpoint.epoch) + + ', root=' + str(new_branch_tip.eventually_justified_checkpoint.root)[:6] + ')') + + # Debug checks + if debug: + # Proposers are aligned with the partition + unexpected_proposers = [b.message.proposer_index for b in new_signed_blocks if + b.message.proposer_index not in branch_tip.participants] + assert len(unexpected_proposers) == 0, \ + 'Unexpected proposer: ' + str(unexpected_proposers[0]) + + # Attesters are aligned with the partition + current_epoch_state = branch_tips[sm_link].beacon_state + for b in new_signed_blocks: + # Attesting indexes from on chain attestations + attesters = attesters_in_block(spec, current_epoch_state, b, current_epoch) + # Attesting indexes from not yet included attestations + for a in new_branch_tip.attestations: + if a.data.target.epoch == current_epoch: + attesters.update( + spec.get_attesting_indices(current_epoch_state, a.data, a.aggregation_bits)) + unexpected_attesters = attesters.difference(branch_tip.participants) + assert len(unexpected_attesters) == 0, \ + 'Unexpected attester: ' + str(unexpected_attesters.pop()) + ', slot ' + str(b.message.slot) + + # Store the result + branch_tips[sm_link] = new_branch_tip + signed_blocks = signed_blocks + new_signed_blocks + + # Sort blocks by a slot + signed_block_messages = [ProtocolMessage(b) for b in signed_blocks] + return sorted(signed_block_messages, key=lambda b: b.payload.message.slot), branch_tips[highest_target_sm_link] + + +def _spoil_block(spec, rnd: random.Random, signed_block): + signed_block.message.state_root = spec.Root(rnd.randbytes(32)) + + +def _spoil_attester_slashing(spec, rnd: random.Random, attester_slashing): + attester_slashing.attestation_2.data = attester_slashing.attestation_1.data + + +def _spoil_attestation(spec, rnd: random.Random, attestation): + attestation.data.target.epoch = spec.GENESIS_EPOCH + + +def _generate_block_tree(spec, + anchor_tip: BranchTip, + rnd: random.Random, + debug, + block_parents, + with_attester_slashings, + with_invalid_messages) -> ([], [], []): + in_block_attestations = anchor_tip.attestations.copy() + post_states = [anchor_tip.beacon_state.copy()] + current_slot = anchor_tip.beacon_state.slot + block_index = 1 + block_tree_tips = set([0]) + in_block_attester_slashings = [] + attester_slashings_count = 0 + out_of_block_attestation_messages = [] + out_of_block_attester_slashing_messages = [] + signed_block_messages = [] + + while block_index < len(block_parents): + # Propose a block if slot shouldn't be empty + if rnd.randint(1, 100) > EMPTY_SLOTS_RATE: + # Advance parent state to the current slot + parent_index = block_parents[block_index] + parent_state = post_states[parent_index].copy() + transition_to(spec, parent_state, current_slot) + + # Filter out non-viable attestations + in_block_attestations = [a for a in in_block_attestations + if parent_state.slot <= a.data.slot + spec.SLOTS_PER_EPOCH] + + # Produce block + proposer = spec.get_beacon_proposer_index(parent_state) + if parent_state.validators[proposer].slashed or ( + with_invalid_messages and rnd.randint(0, 99) < INVALID_MESSAGES_RATE): + # Do not include attestations and slashings into invalid block + # as clients may opt in to process or not process attestations contained by invalid block + signed_block, _, _, _ = produce_block(spec, parent_state, [], []) + _spoil_block(spec, rnd, signed_block) + signed_block_messages.append(ProtocolMessage(signed_block, False)) + # Append the parent state as the post state as if the block were not applied + post_states.append(parent_state) + else: + signed_block, post_state, in_block_attestations, in_block_attester_slashings = produce_block( + spec, parent_state, in_block_attestations, in_block_attester_slashings) + + # Valid block + signed_block_messages.append(ProtocolMessage(signed_block, True)) + post_states.append(post_state) + + # Update tips + block_tree_tips.discard(parent_index) + block_tree_tips.add(block_index) + + # Next block + block_index += 1 + + # Attest to randomly selected tips + def split_list(lst, n): + k, m = divmod(len(lst), n) + return [lst[i * k + min(i, m):(i + 1) * k + min(i + 1, m)] for i in range(n)] + + attesting_tips = rnd.sample(sorted(block_tree_tips), min(len(block_tree_tips), MAX_TIPS_TO_ATTEST)) + validator_count = len(post_states[attesting_tips[0]].validators) + attesters = split_list([i for i in range(validator_count)], len(attesting_tips)) + for index, attesting_block_index in enumerate(attesting_tips): + # Advance the state to the current slot + attesting_state = post_states[attesting_block_index] + transition_to(spec, attesting_state, current_slot) + + # Attest to the block + attestations_in_slot = attest_to_slot(spec, attesting_state, attesting_state.slot, + lambda comm: [i for i in comm if i in attesters[index]]) + + # Sample on chain and off chain attestations + for a in attestations_in_slot: + choice = rnd.randint(0, 99) + if choice < OFF_CHAIN_ATTESTATION_RATE: + if with_invalid_messages and rnd.randint(0, 99) < INVALID_MESSAGES_RATE: + _spoil_attestation(spec, rnd, a) + attestation_message = ProtocolMessage(a, False) + else: + attestation_message = ProtocolMessage(a, True) + out_of_block_attestation_messages.append(attestation_message) + elif choice < OFF_CHAIN_ATTESTATION_RATE + ON_CHAIN_ATTESTATION_RATE: + in_block_attestations.insert(0, a) + else: + out_of_block_attestation_messages.append(ProtocolMessage(a, True)) + in_block_attestations.insert(0, a) + + # Create attester slashing + if with_attester_slashings and attester_slashings_count < MAX_ATTESTER_SLASHINGS: + if rnd.randint(0, 99) < ATTESTER_SLASHINGS_RATE: + state = post_states[attesting_tips[0]] + indices = [rnd.randint(0, len(state.validators) - 1)] + attester_slashing = get_valid_attester_slashing_by_indices(spec, state, indices, + slot=current_slot, + signed_1=True, + signed_2=True) + + choice = rnd.randint(0, 99) + if choice < OFF_CHAIN_SLASHING_RATE: + if with_invalid_messages and rnd.randint(0, 99) < INVALID_MESSAGES_RATE: + _spoil_attester_slashing(spec, rnd, attester_slashing) + attester_slashing_message = ProtocolMessage(attester_slashing, False) + else: + attester_slashing_message = ProtocolMessage(attester_slashing, True) + out_of_block_attester_slashing_messages.append(attester_slashing_message) + elif choice < OFF_CHAIN_SLASHING_RATE + ON_CHAIN_SLASHING_RATE: + in_block_attester_slashings.append(attester_slashing) + else: + out_of_block_attester_slashing_messages.append(ProtocolMessage(attester_slashing, True)) + in_block_attester_slashings.append(attester_slashing) + + attester_slashings_count += 1 + + # Next slot + current_slot += 1 + + if debug: + print('\nblock_tree:') + print('blocks: ', print_block_tree(spec, post_states[0], [b.payload for b in signed_block_messages])) + print(' ', 'state.current_justified_checkpoint:', + '(epoch=' + str(post_states[len(post_states) - 1].current_justified_checkpoint.epoch) + + ', root=' + str(post_states[len(post_states) - 1].current_justified_checkpoint.root)[:6] + ')') + + print('on_block:') + print(' ', 'count =', len(signed_block_messages)) + print(' ', 'valid =', len([b for b in signed_block_messages if b.valid])) + print('on_attestation:') + print(' ', 'count =', len(out_of_block_attestation_messages)) + print(' ', 'valid =', len([a for a in out_of_block_attestation_messages if a.valid])) + print('on_attester_slashing:') + print(' ', 'count =', len(out_of_block_attester_slashing_messages)) + print(' ', 'valid =', len([s for s in out_of_block_attester_slashing_messages if s.valid])) + + return (sorted(signed_block_messages, key=lambda b: b.payload.message.slot), + sorted(out_of_block_attestation_messages, key=lambda a: a.payload.data.slot), + sorted(out_of_block_attester_slashing_messages, key=lambda a: a.payload.attestation_1.data.slot)) + + +def gen_block_tree_test_data(spec, + state, + debug, + seed, + sm_links, + block_parents, + with_attester_slashings, + with_invalid_messages) -> FCTestData: + assert (1, 2) not in sm_links, '(1, 2) sm link is not supported due to unsatisfiability' + sm_links = [SmLink(l) for l in sm_links] + + anchor_state = state + anchor_block = spec.BeaconBlock(state_root=anchor_state.hash_tree_root()) + + # Find a reachable solution trying with different seeds if needed + # sm_links constraints may not have a solution because of the randomization affecting validator partitions + signed_block_messages = [] + highest_tip = BranchTip(state, [], [], state.current_justified_checkpoint) + while True: + if debug: + print('\nseed:', seed) + print('sm_links:', sm_links) + print('block_parents:', block_parents) + + rnd = random.Random(seed) + signed_block_messages, highest_tip = _generate_sm_link_tree(spec, state, sm_links, rnd, debug) + if len(signed_block_messages) > 0: + break + + new_seed = rnd.randint(1, 10000) + print('\nUnsatisfiable constraints: sm_links: ' + str(sm_links) + ', seed=' + str( + seed) + ', will retry with seed=' + str(new_seed)) + seed = new_seed + + # Block tree model + block_tree, attestation_messages, attester_slashing_messages = _generate_block_tree( + spec, highest_tip, rnd, debug, block_parents, with_attester_slashings, with_invalid_messages) + + # Merge block_tree and sm_link_tree blocks + block_tree_root_slot = block_tree[0].payload.message.slot + signed_block_messages = [b for b in signed_block_messages if b.payload.message.slot < block_tree_root_slot] + signed_block_messages = signed_block_messages + block_tree + + # Meta data + meta = { + 'seed': seed, + 'sm_links': str(sm_links), + 'block_parents': str(block_parents), + 'bls_setting': 0 if bls.bls_active else 2, + } + + return FCTestData(meta, anchor_block, anchor_state, + signed_block_messages, attestation_messages, attester_slashing_messages) + + +@with_altair_and_later +@spec_state_test +def yield_block_tree_test_case(spec, + state, + debug=False, + seed=1, + sm_links=None, + block_parents=None, + with_attester_slashings=False, + with_invalid_messages=False): + # This test is mainly used for the test generation purposes + # Thus seed, sm_links and block_parents are provided by the generator + # Define sm_links, seed and block_parents explicitly to execute a certain run of this test + if sm_links is None or block_parents is None: + return + + test_data = gen_block_tree_test_data(spec, state, debug, seed, sm_links, block_parents, + with_attester_slashings, with_invalid_messages) + + store = spec.get_forkchoice_store(test_data.anchor_state, test_data.anchor_block) + yield from yield_fork_choice_test_case(spec, store, test_data, debug) + +@with_altair_and_later +@spec_state_test +def yield_block_tree_test_data(spec, + state, + debug=False, + seed=1, + sm_links=None, + block_parents=None, + with_attester_slashings=False, + with_invalid_messages=False): + # This test is mainly used for the test generation purposes + # Thus seed, sm_links and block_parents are provided by the generator + # Define sm_links, seed and block_parents explicitly to execute a certain run of this test + if sm_links is None or block_parents is None: + return + + test_data = gen_block_tree_test_data(spec, state, debug, seed, sm_links, block_parents, + with_attester_slashings, with_invalid_messages) + yield 'test_data', test_data diff --git a/tests/generators/fork_choice_generated/instantiators/debug_helpers.py b/tests/generators/fork_choice_generated/instantiators/debug_helpers.py new file mode 100644 index 0000000000..1d008685e5 --- /dev/null +++ b/tests/generators/fork_choice_generated/instantiators/debug_helpers.py @@ -0,0 +1,65 @@ +from eth2spec.test.helpers.state import ( + transition_to, +) + + +def attesters_in_block(spec, epoch_state, signed_block, target_epoch): + block = signed_block.message + attesters = set() + for a in block.body.attestations: + if a.data.target.epoch == target_epoch: + attesters.update(spec.get_attesting_indices(epoch_state, a.data, a.aggregation_bits)) + return attesters + + +def print_block(spec, epoch_state, signed_block): + block = signed_block.message + if spec.get_current_epoch(epoch_state) > spec.GENESIS_EPOCH: + prev_attesters = attesters_in_block(spec, epoch_state, signed_block, spec.get_previous_epoch(epoch_state)) + else: + prev_attesters = set() + + curr_attesters = attesters_in_block(spec, epoch_state, signed_block, spec.get_current_epoch(epoch_state)) + prev_attester_str = 'a_prev=' + str(prev_attesters) if any(prev_attesters) else 'a_prev={}' + curr_attester_str = 'a_curr=' + str(curr_attesters) if any(curr_attesters) else 'a_curr={}' + + return 'b(r=' + str(spec.hash_tree_root(block))[:6] + ', p=' + str( + block.proposer_index) + ', ' + prev_attester_str + ', ' + curr_attester_str + ')' + + +def print_slot_range(spec, root_state, signed_blocks, start_slot, end_slot): + ret = "" + epoch_state = root_state.copy() + for slot in range(start_slot, end_slot): + transition_to(spec, epoch_state, slot) + blocks_in_slot = [b for b in signed_blocks if b.message.slot == slot] + if ret != "": + ret = ret + " <- " + if any(blocks_in_slot): + ret = ret + "s(" + str(slot) + ", " + print_block(spec, epoch_state, blocks_in_slot[0]) + ")" + else: + ret = ret + "s(" + str(slot) + ", _)" + + return ret + + +def print_epoch(spec, epoch_state, signed_blocks): + epoch = spec.get_current_epoch(epoch_state) + start_slot = spec.compute_start_slot_at_epoch(epoch) + return print_slot_range(spec, epoch_state, signed_blocks, start_slot, start_slot + spec.SLOTS_PER_EPOCH) + + +def print_block_tree(spec, root_state, signed_blocks): + start_slot = signed_blocks[0].message.slot + end_slot = signed_blocks[len(signed_blocks) - 1].message.slot + 1 + return print_slot_range(spec, root_state, signed_blocks, start_slot, end_slot) + + +def print_head(spec, store): + head = spec.get_head(store) + weight = spec.get_weight(store, head) + state = store.checkpoint_states[store.justified_checkpoint] + total_active_balance = spec.get_total_active_balance(state) + + return '(slot=' + str(store.blocks[head].slot) + ', root=' + str(head)[:6] + ', weight=' + str( + weight * 100 // total_active_balance) + '%)' diff --git a/tests/generators/fork_choice_generated/instantiators/helpers.py b/tests/generators/fork_choice_generated/instantiators/helpers.py new file mode 100644 index 0000000000..cb8c2c76ff --- /dev/null +++ b/tests/generators/fork_choice_generated/instantiators/helpers.py @@ -0,0 +1,420 @@ +from dataclasses import dataclass, field +from .debug_helpers import print_epoch +from eth2spec.utils.ssz.ssz_typing import View +from eth2spec.test.helpers.state import ( + next_slot, +) +from eth2spec.test.helpers.attestations import ( + get_valid_attestation, +) +from eth2spec.test.helpers.block import ( + build_empty_block, + sign_block, +) +from eth2spec.test.helpers.fork_choice import ( + on_tick_and_append_step, + add_attestation, + add_attester_slashing, + add_block, + output_store_checks, + run_on_attestation, + run_on_attester_slashing, + run_on_block, + get_block_file_name, + get_attestation_file_name, + get_attester_slashing_file_name, +) +from .debug_helpers import print_head + +@dataclass +class ProtocolMessage: + payload: object + valid: bool = True + + +@dataclass +class FCTestData: + meta: dict + anchor_block: object + anchor_state: object + blocks: list[ProtocolMessage] + atts: list[ProtocolMessage] = field(default_factory=list) + slashings: list[ProtocolMessage] = field(default_factory=list) + store_final_time: int = 0 + + +class BranchTip: + def __init__(self, beacon_state, attestations, participants, eventually_justified_checkpoint): + self.beacon_state = beacon_state + self.attestations = attestations + self.participants = participants + self.eventually_justified_checkpoint = eventually_justified_checkpoint + + def copy(self): + return BranchTip(self.beacon_state.copy(), + self.attestations.copy(), + self.participants.copy(), + self.eventually_justified_checkpoint) + + +def _get_eligible_attestations(spec, state, attestations) -> []: + def _get_voting_source(target: spec.Checkpoint) -> spec.Checkpoint: + if target.epoch == spec.get_current_epoch(state): + return state.current_justified_checkpoint + else: + return state.previous_justified_checkpoint + + return [a for a in attestations if + state.slot <= a.data.slot + spec.SLOTS_PER_EPOCH + and a.data.source == _get_voting_source(a.data.target)] + + +def _compute_pseudo_randao_reveal(spec, proposer_index, epoch): + pseudo_vrn = spec.uint64((proposer_index + 1) * (epoch + 1)) + pseudo_vrn_bytes = spec.uint_to_bytes(pseudo_vrn) + randao_reveal_bytes = bytes(96 - len(pseudo_vrn_bytes)) + pseudo_vrn_bytes + return spec.BLSSignature(randao_reveal_bytes) + + +def produce_block(spec, state, attestations, attester_slashings=[]): + """ + Produces a block including as many attestations as it is possible. + :return: Signed block, the post block state and attestations that were not included into the block. + """ + + # Filter out too old attestastions (TODO relax condition for Deneb) + eligible_attestations = _get_eligible_attestations(spec, state, attestations) + + # Prepare attestations + attestation_in_block = eligible_attestations[:spec.MAX_ATTESTATIONS] + + # Create a block with attestations + block = build_empty_block(spec, state) + block.body.randao_reveal = _compute_pseudo_randao_reveal( + spec, block.proposer_index, spec.get_current_epoch(state)) + for a in attestation_in_block: + block.body.attestations.append(a) + + # Add attester slashings + attester_slashings_in_block = attester_slashings[:spec.MAX_ATTESTER_SLASHINGS] + for s in attester_slashings_in_block: + block.body.attester_slashings.append(s) + + # Run state transition and sign off on a block + post_state = state.copy() + + valid = True + try: + spec.process_block(post_state, block) + except AssertionError: + valid = False + + block.state_root = post_state.hash_tree_root() + signed_block = sign_block(spec, post_state, block) + + # Filter out operations only if the block is valid + not_included_attestations = attestations + not_included_attester_slashings = attester_slashings + if valid: + not_included_attestations = [a for a in attestations if a not in attestation_in_block] + not_included_attester_slashings = [s for s in attester_slashings if s not in attester_slashings_in_block] + + # Return a pre state if the block is invalid + if not valid: + post_state = state + + return signed_block, post_state, not_included_attestations, not_included_attester_slashings + + +def attest_to_slot(spec, state, slot_to_attest, participants_filter=None) -> []: + """ + Creates attestation is a slot respecting participating validators. + :return: produced attestations + """ + + assert slot_to_attest <= state.slot + + committees_per_slot = spec.get_committee_count_per_slot(state, spec.compute_epoch_at_slot(slot_to_attest)) + attestations_in_slot = [] + for index in range(committees_per_slot): + beacon_committee = spec.get_beacon_committee(state, slot_to_attest, index) + participants = beacon_committee if participants_filter is None else participants_filter(beacon_committee) + if any(participants): + attestation = get_valid_attestation( + spec, + state, + slot_to_attest, + index=index, + signed=True, + filter_participant_set=participants_filter + ) + attestations_in_slot.append(attestation) + + return attestations_in_slot + + +def _compute_eventually_justified_epoch(spec, state, attestations, participants): + # If not all attestations are included on chain + # and attestation.data.target.epoch > beacon_state.current_justified_checkpoint.epoch + # compute eventually_justified_checkpoint, a would be state.current_justified_checkpoint if all attestations + # were included; this computation respects the validator partition that was building the branch + if len(attestations) > 0 \ + and attestations[0].data.target.epoch > state.current_justified_checkpoint.epoch \ + and attestations[0].data.target.epoch > spec.GENESIS_EPOCH: + branch_tip = BranchTip(state, attestations, participants, state.current_justified_checkpoint) + _, new_branch_tip = advance_branch_to_next_epoch(spec, branch_tip, enable_attesting=False) + + return new_branch_tip.beacon_state.current_justified_checkpoint + else: + return state.current_justified_checkpoint + + +def advance_branch_to_next_epoch(spec, branch_tip, enable_attesting=True): + """ + Advances a state of the block tree branch to the next epoch + respecting validators participating in building and attesting to this branch. + + The returned beacon state is advanced to the first slot of the next epoch while no block for that slot is created, + produced attestations that aren't yet included on chain are preserved for the future inclusion. + """ + + def participants_filter(comm): + return [index for index in comm if index in branch_tip.participants] + + signed_blocks = [] + attestations = branch_tip.attestations.copy() + state = branch_tip.beacon_state.copy() + current_epoch = spec.get_current_epoch(state) + target_slot = spec.compute_start_slot_at_epoch(current_epoch + 1) + + while state.slot < target_slot: + # Produce block if the proposer is among participanting validators + proposer = spec.get_beacon_proposer_index(state) + if state.slot > spec.GENESIS_SLOT and proposer in branch_tip.participants: + signed_block, state, attestations, _ = produce_block(spec, state, attestations) + signed_blocks.append(signed_block) + + if enable_attesting: + # Produce attestations + attestations_in_slot = attest_to_slot(spec, state, state.slot, participants_filter) + # And prepend them to the list + attestations = list(attestations_in_slot) + attestations + + # Advance a slot + next_slot(spec, state) + + # Cleanup attestations by removing outdated ones + attestations = [a for a in attestations if + a.data.target.epoch in (spec.get_previous_epoch(state), spec.get_current_epoch(state))] + + eventually_justified_checkpoint = _compute_eventually_justified_epoch(spec, state, attestations, + branch_tip.participants) + + return signed_blocks, BranchTip(state, attestations, branch_tip.participants, eventually_justified_checkpoint) + + +def advance_state_to_anchor_epoch(spec, state, anchor_epoch, debug) -> ([], BranchTip): + signed_blocks = [] + + genesis_tip = BranchTip(state.copy(), [], [*range(0, len(state.validators))], + state.current_justified_checkpoint) + + # Advance the state to the anchor_epoch + anchor_tip = genesis_tip + for epoch in range(spec.GENESIS_EPOCH, anchor_epoch + 1): + pre_state = anchor_tip.beacon_state + new_signed_blocks, anchor_tip = advance_branch_to_next_epoch(spec, anchor_tip) + signed_blocks = signed_blocks + new_signed_blocks + if debug: + post_state = anchor_tip.beacon_state + print('\nepoch', str(epoch) + ':') + print('branch(*, *):', print_epoch(spec, pre_state, new_signed_blocks)) + print(' ', len(anchor_tip.participants), 'participants:', anchor_tip.participants) + print(' ', 'state.current_justified_checkpoint:', + '(epoch=' + str(post_state.current_justified_checkpoint.epoch) + + ', root=' + str(post_state.current_justified_checkpoint.root)[:6] + ')') + print(' ', 'eventually_justified_checkpoint:', + '(epoch=' + str(anchor_tip.eventually_justified_checkpoint.epoch) + + ', root=' + str(anchor_tip.eventually_justified_checkpoint.root)[:6] + ')') + + return signed_blocks, anchor_tip + + +def make_events(spec, test_data: FCTestData) -> list[tuple[int, object, bool]]: + """ + Makes test events from `test_data`'s blocks, attestations and slashings, sorted by an effective slot. + Each event is a triple ('tick'|'block'|'attestation'|'attester_slashing', message, valid). + """ + genesis_time = test_data.anchor_state.genesis_time + test_events = [] + + def slot_to_time(slot): + return slot * spec.config.SECONDS_PER_SLOT + genesis_time + + def add_tick_step(time): + test_events.append(('tick', time, None)) + + def add_message_step(kind, message): + test_events.append((kind, message.payload, message.valid)) + + add_tick_step(slot_to_time(test_data.anchor_state.slot)) + slot = test_data.anchor_state.slot + + def get_seffective_slot(message): + event_kind, data, _ = message + if event_kind == 'block': + return data.message.slot + elif event_kind == 'attestation': + return data.data.slot + 1 + elif event_kind == 'attester_slashing': + return max(data.attestation_1.data.slot, data.attestation_1.data.slot) + 1 + else: + assert False + + messages = [('attestation', m.payload, m.valid) for m in test_data.atts] \ + + [('attester_slashing', m.payload, m.valid) for m in test_data.slashings] \ + + [('block', m.payload, m.valid) for m in test_data.blocks] + + for event in sorted(messages, key=get_seffective_slot): + event_kind, message, valid = event + event_slot = get_seffective_slot(event) + while slot < event_slot: + slot += 1 + add_tick_step(slot_to_time(slot)) + add_message_step(event_kind, ProtocolMessage(message, valid)) + + if slot is None or slot_to_time(slot) < test_data.store_final_time: + add_tick_step(test_data.store_final_time) + + return test_events + + +def filter_out_duplicate_messages(fn): + def wrapper(*args, **kwargs): + processed_keys = set() + for data in fn(*args, **kwargs): + if len(data) != 2: + yield data + else: + (key, value) = data + if value is not None and isinstance(value, (bytes, View)): + # skip already processed ssz parts + if key not in processed_keys: + processed_keys.add(key) + yield data + else: + yield data + return wrapper + + +def _add_block(spec, store, signed_block, test_steps): + """ + Helper method to add a block, when it's unknown whether it's valid or not + """ + yield get_block_file_name(signed_block), signed_block + try: + run_on_block(spec, store, signed_block) + valid = True + except AssertionError: + valid = False + + test_steps.append({'block': get_block_file_name(signed_block), 'valid': valid}) + + if valid: + # An on_block step implies receiving block's attestations + for attestation in signed_block.message.body.attestations: + try: + run_on_attestation(spec, store, attestation, is_from_block=True, valid=True) + except AssertionError: + # ignore possible faults, if the block is valud + pass + + # An on_block step implies receiving block's attester slashings + for attester_slashing in signed_block.message.body.attester_slashings: + try: + run_on_attester_slashing(spec, store, attester_slashing, valid=True) + except AssertionError: + # ignore possible faults, if the block is valud + pass + + +@filter_out_duplicate_messages +def yield_fork_choice_test_events(spec, store, test_data: FCTestData, test_events: list, debug: bool): + # Yield meta + for k, v in test_data.meta.items(): + yield k, 'meta', v + + # Yield anchor state and block initialization + yield 'anchor_state', test_data.anchor_state + yield 'anchor_block', test_data.anchor_block + + for message in test_data.blocks: + block = message.payload + yield get_block_file_name(block), block.encode_bytes() + + for message in test_data.atts: + attestation = message.payload + yield get_attestation_file_name(attestation), attestation.encode_bytes() + + for message in test_data.slashings: + attester_slashing = message.payload + yield get_attester_slashing_file_name(attester_slashing), attester_slashing.encode_bytes() + + test_steps = [] + + def try_add_mesage(runner, message): + try: + runner(spec, store, message, valid=True) + return True + except AssertionError: + return False + + # record initial tick + on_tick_and_append_step(spec, store, store.time, test_steps) + + for event in test_events: + event_kind = event[0] + if event_kind == 'tick': + _, time, _ = event + if time > store.time: + on_tick_and_append_step(spec, store, time, test_steps) + assert store.time == time + elif event_kind == 'block': + _, signed_block, valid = event + if valid is None: + yield from _add_block(spec, store, signed_block, test_steps) + else: + yield from add_block(spec, store, signed_block, test_steps, valid=valid) + + block_root = signed_block.message.hash_tree_root() + if valid: + assert store.blocks[block_root] == signed_block.message + else: + assert block_root not in store.blocks.values() + output_store_checks(spec, store, test_steps) + elif event_kind == 'attestation': + _, attestation, valid = event + if valid is None: + valid = try_add_mesage(run_on_attestation, attestation) + yield from add_attestation(spec, store, attestation, test_steps, valid=valid) + output_store_checks(spec, store, test_steps) + elif event_kind == 'attester_slashing': + _, attester_slashing, valid = event + if valid is None: + valid = try_add_mesage(run_on_attester_slashing, attester_slashing) + yield from add_attester_slashing(spec, store, attester_slashing, test_steps, valid=valid) + output_store_checks(spec, store, test_steps) + else: + raise ValueError('Unknown event ' + str(event_kind)) + + if debug: + print(' head: ' + print_head(spec, store)) + + output_store_checks(spec, store, test_steps, with_viable_for_head_weights=True) + + yield 'steps', test_steps + + +def yield_fork_choice_test_case(spec, store, test_data: FCTestData, debug: bool): + test_events = make_events(spec, test_data) + yield from yield_fork_choice_test_events(spec, store, test_data, test_events, debug) diff --git a/tests/generators/fork_choice_generated/instantiators/mutation_operators.py b/tests/generators/fork_choice_generated/instantiators/mutation_operators.py new file mode 100644 index 0000000000..d5fdeb6ea2 --- /dev/null +++ b/tests/generators/fork_choice_generated/instantiators/mutation_operators.py @@ -0,0 +1,131 @@ +import random + + +def mut_shift_(tv, idx, delta): + time, event = tv[idx] + new_time = int(time) + delta + if new_time >= 0: + return sorted(tv[:idx] + [(new_time, event)] + tv[idx+1:], key=lambda x: x[0]) + else: + return idx + + +def mut_shift(tv, rnd: random.Random): + idx = rnd.choice(range(len(tv))) + idx_time = tv[idx][0] + dir = rnd.randint(0, 1) + if idx_time == 0 or dir: + time_shift = rnd.randint(0, 6) * 3 + else: + time_shift = -rnd.randint(0, idx_time // 3) + return mut_shift_(tv, idx, time_shift) + + +def mut_drop_(tv, idx): + return tv[:idx] + tv[idx+1:] + + +def mut_drop(tv, rnd: random.Random): + idx = rnd.choice(range(len(tv))) + return mut_drop_(tv, idx) + + +def mut_dup_(tv, idx, shift): + return mut_shift_(tv + [tv[idx]], len(tv), shift) + + +def mutate_test_vector(rnd, initial_tv, cnt, debug=False): + tv_ = initial_tv + for i in range(cnt): + coin = rnd.randint(0, 1) + if coin: + if debug: + print(" mutating initial tv") + tv__ = initial_tv + else: + if debug: + print(" mutating tv_") + tv__ = tv_ + tv = tv__ + op_kind = rnd.randint(0, 2) + if op_kind == 0: + idx = rnd.choice(range(len(tv))) + if debug: + print(f" dropping {idx}") + tv_ = mut_drop_(tv, idx) + elif op_kind == 1: + idx = rnd.choice(range(len(tv))) + idx_time = tv[idx][0] + dir = rnd.randint(0, 1) + if idx_time == 0 or dir: + time_shift = rnd.randint(0, 6) * 3 + else: + time_shift = -rnd.randint(0, idx_time // 3) * 3 + if debug: + print(f" shifting {idx} by {time_shift}") + tv_ = mut_shift_(tv, idx, time_shift) + elif op_kind == 2: + idx = rnd.choice(range(len(tv))) + shift = rnd.randint(0, 5) * 3 + if debug: + print(f" dupping {idx} and shifting by {shift}") + tv_ = mut_dup_(tv, idx, shift) + else: + assert False + yield tv_ + + +class MutationOps: + def __init__(self, start_time, seconds_per_slot, shift_bounds=(-2,4)): + self.start_time = int(start_time) + self.seconds_per_slot = int(seconds_per_slot) + self.shift_bounds = shift_bounds + + def apply_shift(self, tv, idx, delta): + return mut_shift_(tv, idx, delta) + + def apply_drop(self, tv, idx): + return mut_drop_(tv, idx) + + def apply_dup_shift(self, tv, idx, delta): + return mut_dup_(tv, idx, delta) + + def apply_mutation(self, tv, op_kind, *params): + if op_kind == 'shift': + return self.apply_shift(tv, *params) + elif op_kind == 'dup_shift': + return self.apply_dup_shift(tv, *params) + elif op_kind == 'drop': + return self.apply_drop(tv, *params) + else: + assert False + + def rand_shift(self, time: int, rnd: random.Random) -> int: + assert time >= self.start_time + neg_shift, pos_shift = self.shift_bounds + min_shift = max(self.start_time - time, neg_shift * self.seconds_per_slot) + max_shift = pos_shift * self.seconds_per_slot + if rnd.randint(0, 1) == 0: + return rnd.randint(min_shift, 0) + else: + return rnd.randint(1, max_shift) + + def rand_mutation(self, tv, rnd: random.Random): + idx = rnd.choice(range(len(tv))) + op_kind = rnd.choice(['shift', 'drop', 'dup_shift']) + if op_kind == 'shift' or op_kind == 'dup_shift': + evt_time = int(tv[idx][0]) + params = idx, self.rand_shift(evt_time, rnd) + else: + params = idx, + return op_kind, *params + + def rand_mutations(self, tv, num, rnd: random.Random): + mutations = [] + for _ in range(num): + if len(tv) == 0: + break + mut_op = self.rand_mutation(tv, rnd) + mutations.append(mut_op) + tv = self.apply_mutation(tv, *mut_op) + return tv, mutations diff --git a/tests/generators/fork_choice_generated/model/gecode_config/gecode.msc b/tests/generators/fork_choice_generated/model/gecode_config/gecode.msc new file mode 100644 index 0000000000..7ef0fa7fd3 --- /dev/null +++ b/tests/generators/fork_choice_generated/model/gecode_config/gecode.msc @@ -0,0 +1,16 @@ +{ + "id": "org.gecode.gecode", + "name": "Gecode", + "description": "Gecode FlatZinc executable", + "version": "6.2.0", + "mznlib": "/usr/local/share/gecode", + "executable": "/usr/local/bin/fzn-gecode", + "tags": ["cp","int", "float", "set", "restart"], + "stdFlags": ["-a","-f","-n","-p","-r","-s","-t"], + "supportsMzn": false, + "supportsFzn": true, + "needsSolns2Out": true, + "needsMznExecutable": false, + "needsStdlibDir": false, + "isGUIApplication": false +} diff --git a/tests/generators/fork_choice_generated/model/minizinc/Block_cover.mzn b/tests/generators/fork_choice_generated/model/minizinc/Block_cover.mzn new file mode 100644 index 0000000000..9c3f2e0f9c --- /dev/null +++ b/tests/generators/fork_choice_generated/model/minizinc/Block_cover.mzn @@ -0,0 +1,39 @@ +include "globals.mzn"; + +int: NE = 4; +int: NS = NE * 2; +int: NB = 5; + +type Block = record(var SLOT: slot, var BLOCK: parent, var EPOCH: bje, var EPOCH: buje); + +function var int: s2e(var int: e) = e div 2; +predicate valid_block(var BLOCK: b) = + let {var int: ep = s2e(slot[b]); var int: je = bje[b]; var int: uje = buje[b]} + in je <= uje /\ je <= ep /\ (ep != 0 -> je < ep) /\ uje <= ep; + +set of int: BLOCK = 0..(NB-1); +set of int: SLOT = 0..(NS-1); +set of int: EPOCH = 0..(NE-1); +array[BLOCK] of var BLOCK: parent; +array[BLOCK] of var SLOT: slot; +array[BLOCK] of var EPOCH: bje; +array[BLOCK] of var EPOCH: buje; + +var int: sje; +var int: suje; + + + +constraint maximum(sje, bje); +constraint maximum(suje, buje); + +constraint parent[0] == 0 /\ slot[0] == 0 /\ bje[0] == 0 /\ buje[0] == 0; +constraint forall(i in BLOCK)(if i == 0 then parent[i] == i else parent[i] != i endif); +constraint strictly_increasing(slot); +constraint forall(i in BLOCK)(valid_block(i)); +constraint buje[NB-1] > 2; + +constraint pred1 <-> is_leaf(block); +constraint pred2 <-> is_anscestor_of_sje(block); + +solve satisfy; diff --git a/tests/generators/fork_choice_generated/model/minizinc/Block_cover3.mzn b/tests/generators/fork_choice_generated/model/minizinc/Block_cover3.mzn new file mode 100644 index 0000000000..4845d4c88c --- /dev/null +++ b/tests/generators/fork_choice_generated/model/minizinc/Block_cover3.mzn @@ -0,0 +1,71 @@ +include "globals.mzn"; + +int: AE; +int: MB = 4; + +set of int: EPOCH = AE..(AE+MB-1); +set of int: BLOCK = 0..MB; + +type BS = record(EPOCH: e, EPOCH: je, EPOCH: uje); + + +array[BLOCK] of var EPOCH: es; +array[BLOCK] of var EPOCH: pjes; +array[BLOCK] of var EPOCH: cjes; +array[BLOCK] of var EPOCH: ujes; +array[BLOCK] of var bool: prevs; +array[BLOCK] of var bool: currs; +array[BLOCK] of var BLOCK: parents; + +function var EPOCH: n_e(var BLOCK: b) = es[b] + 1; +function var EPOCH: n_pje(var BLOCK: b) = cjes[b]; +function var EPOCH: n_cje(var BLOCK: b) = + if currs[b] then + es[b] + elseif prevs[b] then + es[b] - 1 + else + cjes[b] + endif; + +constraint es[0] == AE; +constraint pjes[0] == AE /\ cjes[0] == AE; +constraint forall(b in BLOCK)(if b > 0 then parents[b] < b else parents[b] == b endif); + +constraint forall(b in BLOCK where b > 0)(n_e(parents[b]) == es[b] /\ n_pje(parents[b]) == pjes[b] /\ n_cje(parents[b]) == cjes[b]); +constraint forall(b in BLOCK)(ujes[b] == n_cje(b)); + +function var EPOCH: get_vse(var BLOCK: b) = + if es[b] < curr_e then n_cje(b) else cjes[b] endif; + +var EPOCH: curr_e; +var EPOCH: store_je; + +constraint forall(b in BLOCK)(es[b] <= curr_e); +constraint forall(b in BLOCK)(get_vse(b) <= store_je); +constraint exists(b in BLOCK)(get_vse(b) == store_je); + +predicate is_leaf(var BLOCK: b) = not exists(child in BLOCK where child > b /\ child <= max_block)(parents[child] == b); + +var BLOCK: target_block; +var BLOCK: max_block; + +constraint get_vse(max_block) == store_je; +constraint target_block <= max_block; + +bool: store_je_eq_zero; +bool: store_fe_eq_zero = true; +bool: block_vse_eq_store_je; +bool: block_vse_plus_two_ge_curr_e; +bool: block_is_leaf; +bool: block_is_store_jb_descendant = true; +bool: block_is_store_fb_descendant = true; + +constraint block_vse_eq_store_je <-> get_vse(target_block) == store_je; +constraint block_vse_plus_two_ge_curr_e <-> get_vse(target_block) + 2 >= curr_e; +constraint block_is_leaf <-> is_leaf(target_block); +constraint store_je_eq_zero <-> store_je == 0; +% constraint block_is_justified_descendant <-> common_ancestor(target_block, store_jb) == store_jb; + +% constraint store_fe_eq_zero <-> store_fe == 0; +% constraint block_is_finalized_descendant <-> common_ancestor(target_block, store_fb) == store_fb; diff --git a/tests/generators/fork_choice_generated/model/minizinc/Block_predicates.mzn b/tests/generators/fork_choice_generated/model/minizinc/Block_predicates.mzn new file mode 100644 index 0000000000..1cb0703004 --- /dev/null +++ b/tests/generators/fork_choice_generated/model/minizinc/Block_predicates.mzn @@ -0,0 +1,45 @@ +include "globals.mzn"; + +int: NoE = 4; +int: maxE = NoE - 1; +set of int: EPOCH = 0..maxE; + +type BS = record(EPOCH: e, EPOCH: je, EPOCH: uje); + + +var BS: block; +var EPOCH: curr_e; +var EPOCH: store_je; + +function var EPOCH: get_vse(var BS: block) = + if block.e < curr_e then block.uje else block.je endif; + +predicate valid_block_epochs(var BS: block) = + block.e <= curr_e /\ + block.je <= block.uje /\ (block.e != 0 -> block.je < block.e) /\ block.uje <= block.e; + +predicate valid_store_je() = + let { var BS: best_block; constraint valid_block_epochs(best_block); } + in get_vse(best_block) = store_je; + + +constraint valid_store_je(); +constraint get_vse(block) <= store_je; +constraint valid_block_epochs(block); + + +bool: store_je_eq_zero = false; +bool: block_vse_eq_store_je = false; +bool: prev_e_justified = false; +bool: block_uje_ge_store_je = false; +bool: block_vse_plus_two_ge_curr_e = false; +%bool: block_is_leaf; +%bool: block_descendant_of_store_just_root; +%bool: block_descendant_of_store_fin_chkpt; +%bool: block_fe_eq_zero = false; + +constraint store_je_eq_zero <-> store_je == 0; +constraint block_vse_eq_store_je <-> get_vse(block) == store_je; +constraint prev_e_justified <-> store_je == curr_e - 1; +constraint block_uje_ge_store_je <-> block.uje >= store_je; +constraint block_vse_plus_two_ge_curr_e <-> get_vse(block) + 2 >= curr_e; diff --git a/tests/generators/fork_choice_generated/model/minizinc/Block_tree.mzn b/tests/generators/fork_choice_generated/model/minizinc/Block_tree.mzn new file mode 100644 index 0000000000..ee54f9e534 --- /dev/null +++ b/tests/generators/fork_choice_generated/model/minizinc/Block_tree.mzn @@ -0,0 +1,38 @@ +include "globals.mzn"; + +int: NB; % num of blocks +% int: MD; % max depth +% int: MW; % max width +int: MC; % max children + +set of int: BLOCKS = 0..(NB-1); + +array[BLOCKS] of var BLOCKS: parent; +% array[BLOCKS] of var set of BLOCKS: children; +% array[BLOCKS] of var int: depths; +% array[BLOCKS] of var int: widths; + +function var int: count_children(var BLOCKS: block) = + sum(ch in BLOCKS)(if ch != 0 /\ parent[ch] == block then 1 else 0 endif); + +% function var int: sub_tree_size(var BLOCKS: block) = +% if count_children(block) == 0 then +% 1 +% else +% sum(ch in BLOCKS)(if ch != 0 /\ parent[ch] == block then sub_tree_size(ch) else 0 endif) +% endif; + + +% array[BLOCKS] of var int: tst; +% array[BLOCKS] of var int: tst2; + +% constraint forall(b in BLOCKS)(tst[b] == count_children(b)); +% constraint forall(b in BLOCKS)(tst2[b] == card(children[b])); +% constraint int_set_channel(parent, children); +% constraint forall(b in BLOCKS)(if b == 0 then depths[b] == 0 else depths[b] == depths[parent[b]] + 1 endif); + +constraint forall(b in BLOCKS)(if b != 0 then parent[b] < b else parent[b] == b endif); +constraint forall(b in BLOCKS)(count_children(b) <= MC); +% constraint forall(b in BLOCKS)(depths[b] <= MD); +% constraint forall(b in BLOCKS)(widths[b] == sub_tree_size(b)); +% constraint forall(b in BLOCKS)(widths[b] <= MW); \ No newline at end of file diff --git a/tests/generators/fork_choice_generated/model/minizinc/Chain.mzn b/tests/generators/fork_choice_generated/model/minizinc/Chain.mzn new file mode 100644 index 0000000000..54c4e17d15 --- /dev/null +++ b/tests/generators/fork_choice_generated/model/minizinc/Chain.mzn @@ -0,0 +1,100 @@ +include "globals.mzn"; + +int: NoE = 5; +int: maxE = NoE - 1; +set of int: EPOCH = 0..maxE; + +type SML = record(EPOCH: source, EPOCH: target); +type BS = record(EPOCH: e, EPOCH: je, EPOCH: uje); + + +var BS: block; +var EPOCH: curr_e; +var EPOCH: store_je; + +function var EPOCH: get_vse(var BS: block) = + if block.e < curr_e then block.uje else block.je endif; + +predicate valid_block_epochs(var BS: block) = + block.e <= curr_e /\ + block.je <= block.uje /\ (block.e != 0 -> block.je < block.e) /\ block.uje <= block.e; + +predicate valid_store_je() = + let { var BS: best_block; constraint valid_block_epochs(best_block); } + in get_vse(best_block) = store_je; + + +type BSt = record(EPOCH: e, EPOCH: pje, EPOCH: cje); + +predicate ok(var opt int: v) = + not absent(v); + +predicate ok_sml(var opt SML: sml) = + ok(sml.source) /\ ok(sml.target); + +predicate correct_sml(var opt SML: sml) = + ok(sml.source) <-> ok(sml.target); + +predicate valid_link(var opt SML: sml, var EPOCH: src, var EPOCH: tgt) = + if ok_sml(sml) then + sml.source == src /\ sml.target == tgt + endif + ; + +function var BSt: epoch_trans(var BSt: block, var opt SML: p_sml, var opt SML: c_sml) = + let { + var EPOCH: new_pje = block.cje; + var EPOCH: new_cje = + if ok_sml(c_sml) /\ valid_link(c_sml, block.cje, block.e) then + block.e + else + if ok_sml(p_sml) /\ valid_link(p_sml, block.pje, block.e-1) then + block.e - 1 + else + block.cje + endif + endif; + } in (e: block.e + 1, pje: new_pje, cje: new_cje); + + +constraint valid_store_je(); +constraint get_vse(block) <= store_je; +constraint valid_block_epochs(block); +%constraint block.e >= 2 /\ block.je >= 1; +%constraint block.je < block.uje /\ block.e < curr_e; + + +opt bool: store_je_eq_zero = true; +opt bool: block_vse_eq_store_je = <>; +opt bool: prev_e_justified = <>; +opt bool: block_uje_ge_store_je = <>; +opt bool: block_vse_plus_two_ge_curr_e = <>; +%bool: block_is_leaf; +%bool: block_descendant_of_store_just_root; +%bool: block_descendant_of_store_fin_chkpt; +%bool: block_fe_eq_zero = false; + +constraint store_je_eq_zero <-> (store_je == 0); +constraint block_vse_eq_store_je <-> (get_vse(block) == store_je); +constraint prev_e_justified <-> (store_je == curr_e - 1); +constraint block_uje_ge_store_je <-> (block.uje >= store_je); +constraint block_vse_plus_two_ge_curr_e <-> (get_vse(block) + 2 >= curr_e); + + +predicate epoch_trans_p(var BSt: b, var opt SML: sml, var BSt: r) = + r.e == b.e + 1 + /\ r.pje = b.cje + /\ if ok_sml(sml) then + (r.cje = b.e /\ sml.source = b.cje /\ sml.target = b.e) + \/ (r.cje = b.e - 1 /\ sml.source = b.pje /\ sml.target = b.e-1) + else + r.cje = b.cje + endif; + +function var bool: etclo(array[0..maxE] of var BSt: sts, int: sz) = + sts[0] = (e: 0, pje: 0, cje: 0) + /\ forall(i in 0..sz-1) (epoch_trans_p(sts[i], smls[i], sts[i+1])); + +array[0..maxE] of var BSt: sts; +array[0..maxE-1] of var opt SML: smls; +constraint etclo(sts, 2); diff --git a/tests/generators/fork_choice_generated/model/minizinc/Epoch_Transition.mzn b/tests/generators/fork_choice_generated/model/minizinc/Epoch_Transition.mzn new file mode 100644 index 0000000000..d6390522a0 --- /dev/null +++ b/tests/generators/fork_choice_generated/model/minizinc/Epoch_Transition.mzn @@ -0,0 +1,49 @@ +include "globals.mzn"; + +int: NoE = 5; +int: maxE = NoE-1; +set of int: EPOCH = 0..maxE; +int: NoL = 3; +set of int: LINKS = 0..NoL-1; + + +array[0..maxE] of var EPOCH: epochs; +array[0..maxE] of var EPOCH: pjes; +array[0..maxE] of var EPOCH: cjes; + +array[LINKS] of var EPOCH: sources; +array[LINKS] of var EPOCH: targets; + + +predicate ex_link(var EPOCH: src, var EPOCH: tgt) = + exists(i in LINKS)(sources[i] == src /\ targets[i] == tgt); + + +predicate trans(0..maxE: from, 0..maxE: to) = + let { + var EPOCH: e = epochs[from]; var EPOCH: cje = cjes[from]; var EPOCH: pje = pjes[from]; + var EPOCH: ne = epochs[to]; var EPOCH: ncje = cjes[to]; var EPOCH: npje = pjes[to]; + var bool: curr_link = ex_link(cje, e); var bool: prev_link = (e > 0) -> ex_link(pje, e-1); + } in + ((curr_link /\ ncje == e) + \/ (prev_link /\ ncje == e-1) + \/ (ncje == cje)) + /\ npje == cje /\ ne == e + 1 +; + + +predicate surround_vote(var LINKS: a, var LINKS: b) = + sources[a] < sources[b] /\ targets[b] < targets[a]; + + +constraint forall(i in LINKS)(sources[i] < targets[i]); +constraint forall(i in LINKS)(sources[i] == 0 \/ member(targets, sources[i])); +constraint strictly_increasing(targets); +constraint forall(i,j in LINKS where i != j)(not surround_vote(i,j)); + +constraint epochs[0] == 0; +constraint pjes[0] == 0; +constraint cjes[0] == 0; +constraint forall(i in 0..maxE-1)(trans(i, i+1)); + + diff --git a/tests/generators/fork_choice_generated/model/minizinc/SM_links.mzn b/tests/generators/fork_choice_generated/model/minizinc/SM_links.mzn new file mode 100644 index 0000000000..93b6cfba78 --- /dev/null +++ b/tests/generators/fork_choice_generated/model/minizinc/SM_links.mzn @@ -0,0 +1,22 @@ +include "globals.mzn"; + +int: AE; % anchor epoch +int: NE; % num of epochs +int: NL; % num of super-majority links + +set of int: EPOCH = AE..(AE+NE-1); +set of int: LINKS = 0..(NL-1); + +array[LINKS] of var EPOCH: sources; +array[LINKS] of var EPOCH: targets; + +predicate surround_vote(var LINKS: a, var LINKS: b) = + sources[a] < sources[b] /\ targets[b] < targets[a]; + +constraint forall(i in LINKS)(sources[i] < targets[i]); +constraint forall(i in LINKS)(sources[i] == AE \/ member(targets, sources[i])); +constraint strictly_increasing(targets); +constraint forall(i,j in LINKS where i != j)(not surround_vote(i,j)); + +% Exclude (1, 2) SM link which is unreachable for the Gasper protocol +constraint forall(i in LINKS)(not (sources[i] == 1 /\ targets[i] == 2)); diff --git a/tests/generators/fork_choice_generated/requirements.txt b/tests/generators/fork_choice_generated/requirements.txt new file mode 100644 index 0000000000..d41c75d07a --- /dev/null +++ b/tests/generators/fork_choice_generated/requirements.txt @@ -0,0 +1,3 @@ +pytest>=4.4 +minizinc>=0.9.0 +../../../[generator] diff --git a/tests/generators/fork_choice_generated/sample_attester_slashings.yaml b/tests/generators/fork_choice_generated/sample_attester_slashings.yaml new file mode 100644 index 0000000000..a3f0669faa --- /dev/null +++ b/tests/generators/fork_choice_generated/sample_attester_slashings.yaml @@ -0,0 +1,153 @@ +- block_parents: [0, 0, 1, 2, 3, 4, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0] + sm_links: &id001 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 3, 3, 2, 2, 1, 1, 0, 0] + sm_links: *id001 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 3, 3, 2, 2, 1, 1, 0, 0] + sm_links: *id001 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 3, 2, 2, 1, 1, 0, 0] + sm_links: *id001 +- block_parents: &id003 [0, 0, 0, 0] + sm_links: &id002 + - [0, 1] + - [0, 2] + - [0, 3] +- block_parents: &id004 [0, 0, 1, 0] + sm_links: *id002 +- block_parents: &id006 [0, 0, 0, 1] + sm_links: *id002 +- block_parents: &id007 [0, 0, 1, 1] + sm_links: *id002 +- block_parents: *id003 + sm_links: &id005 + - [0, 1] + - [0, 2] + - [1, 3] +- block_parents: *id004 + sm_links: *id005 +- block_parents: *id006 + sm_links: *id005 +- block_parents: *id007 + sm_links: *id005 +- block_parents: *id003 + sm_links: &id008 + - [0, 1] + - [0, 2] + - [2, 3] +- block_parents: *id004 + sm_links: *id008 +- block_parents: *id006 + sm_links: *id008 +- block_parents: *id007 + sm_links: *id008 +- block_parents: &id010 [0, 0, 0, 0] + sm_links: &id009 + - [0, 1] + - [0, 2] + - [0, 3] + - [0, 4] +- block_parents: &id011 [0, 0, 1, 0] + sm_links: *id009 +- block_parents: &id013 [0, 0, 0, 1] + sm_links: *id009 +- block_parents: &id014 [0, 0, 1, 1] + sm_links: *id009 +- block_parents: *id010 + sm_links: &id012 + - [0, 1] + - [0, 2] + - [0, 3] + - [1, 4] +- block_parents: *id011 + sm_links: *id012 +- block_parents: *id013 + sm_links: *id012 +- block_parents: *id014 + sm_links: *id012 +- block_parents: *id010 + sm_links: &id015 + - [0, 1] + - [0, 2] + - [0, 3] + - [2, 4] +- block_parents: *id011 + sm_links: *id015 +- block_parents: *id013 + sm_links: *id015 +- block_parents: *id014 + sm_links: *id015 +- block_parents: *id010 + sm_links: &id016 + - [0, 1] + - [0, 2] + - [0, 3] + - [3, 4] +- block_parents: *id011 + sm_links: *id016 +- block_parents: *id013 + sm_links: *id016 +- block_parents: *id014 + sm_links: *id016 +- block_parents: *id010 + sm_links: &id017 + - [0, 1] + - [0, 2] + - [1, 3] + - [1, 4] +- block_parents: *id011 + sm_links: *id017 +- block_parents: *id013 + sm_links: *id017 +- block_parents: *id014 + sm_links: *id017 +- block_parents: *id010 + sm_links: &id018 + - [0, 1] + - [0, 2] + - [1, 3] + - [2, 4] +- block_parents: *id011 + sm_links: *id018 +- block_parents: *id013 + sm_links: *id018 +- block_parents: *id014 + sm_links: *id018 +- block_parents: *id010 + sm_links: &id019 + - [0, 1] + - [0, 2] + - [1, 3] + - [3, 4] +- block_parents: *id011 + sm_links: *id019 +- block_parents: *id013 + sm_links: *id019 +- block_parents: *id014 + sm_links: *id019 +- block_parents: *id010 + sm_links: &id020 + - [0, 1] + - [0, 2] + - [2, 3] + - [2, 4] +- block_parents: *id011 + sm_links: *id020 +- block_parents: *id013 + sm_links: *id020 +- block_parents: *id014 + sm_links: *id020 +- block_parents: *id010 + sm_links: &id021 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: *id011 + sm_links: *id021 +- block_parents: *id013 + sm_links: *id021 +- block_parents: *id014 + sm_links: *id021 diff --git a/tests/generators/fork_choice_generated/sample_block_cover.yaml b/tests/generators/fork_choice_generated/sample_block_cover.yaml new file mode 100644 index 0000000000..d04d3b1408 --- /dev/null +++ b/tests/generators/fork_choice_generated/sample_block_cover.yaml @@ -0,0 +1,162 @@ +- block_epochs: [0] + current_epoch: 1 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: true} + previous_justifications: [false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1] + current_epoch: 1 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: true} + previous_justifications: [false, false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0] + current_epoch: 3 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: true} + previous_justifications: [false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1] + current_epoch: 3 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: true} + previous_justifications: [false, false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1, 1] + current_epoch: 2 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 1 + target_block: 2 +- block_epochs: [0, 1, 1, 2, 2] + current_epoch: 2 + current_justifications: [false, true, false, false, false] + parents: [0, 0, 0, 1, 1] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false, false, false, false] + store_justified_epoch: 1 + target_block: 1 +- block_epochs: [0, 1, 1] + current_epoch: 2 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 1 + target_block: 1 +- block_epochs: [0, 1] + current_epoch: 2 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 1 + target_block: 0 +- block_epochs: [0, 1, 1] + current_epoch: 3 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 1 + target_block: 1 +- block_epochs: [0, 1] + current_epoch: 3 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 1 + target_block: 0 +- block_epochs: [2] + current_epoch: 3 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 3 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2] + current_epoch: 5 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 5 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3, 3] + current_epoch: 4 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 3 + target_block: 1 +- block_epochs: [2, 3] + current_epoch: 4 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 3 + target_block: 0 +- block_epochs: [2, 3, 3] + current_epoch: 5 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 3 + target_block: 1 +- block_epochs: [2, 3] + current_epoch: 5 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 3 + target_block: 0 diff --git a/tests/generators/fork_choice_generated/sample_block_tree.yaml b/tests/generators/fork_choice_generated/sample_block_tree.yaml new file mode 100644 index 0000000000..1ac1eafb79 --- /dev/null +++ b/tests/generators/fork_choice_generated/sample_block_tree.yaml @@ -0,0 +1,191 @@ +- block_parents: &id002 [0, 0, 1, 2, 3, 4, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0] + sm_links: &id001 + - [0, 1] + - [0, 2] +- block_parents: &id003 [0, 0, 1, 2, 3, 4, 5, 4, 3, 3, 2, 2, 1, 1, 0, 0] + sm_links: *id001 +- block_parents: &id005 [0, 0, 1, 2, 3, 4, 4, 5, 3, 3, 2, 2, 1, 1, 0, 0] + sm_links: *id001 +- block_parents: &id006 [0, 0, 1, 2, 3, 4, 5, 5, 3, 3, 2, 2, 1, 1, 0, 0] + sm_links: *id001 +- block_parents: *id002 + sm_links: &id004 + - [0, 1] + - [0, 3] +- block_parents: *id003 + sm_links: *id004 +- block_parents: *id005 + sm_links: *id004 +- block_parents: *id006 + sm_links: *id004 +- block_parents: *id002 + sm_links: &id007 + - [0, 2] + - [0, 3] +- block_parents: *id003 + sm_links: *id007 +- block_parents: *id005 + sm_links: *id007 +- block_parents: *id006 + sm_links: *id007 +- block_parents: *id002 + sm_links: &id008 + - [0, 1] + - [1, 3] +- block_parents: *id003 + sm_links: *id008 +- block_parents: *id005 + sm_links: *id008 +- block_parents: *id006 + sm_links: *id008 +- block_parents: *id002 + sm_links: &id009 + - [0, 2] + - [2, 3] +- block_parents: *id003 + sm_links: *id009 +- block_parents: *id005 + sm_links: *id009 +- block_parents: *id006 + sm_links: *id009 +- block_parents: &id011 [0, 0, 0, 0] + sm_links: &id010 + - [0, 1] + - [0, 2] + - [0, 3] +- block_parents: &id012 [0, 0, 1, 0] + sm_links: *id010 +- block_parents: &id014 [0, 0, 0, 1] + sm_links: *id010 +- block_parents: &id015 [0, 0, 1, 1] + sm_links: *id010 +- block_parents: *id011 + sm_links: &id013 + - [0, 1] + - [0, 2] + - [1, 3] +- block_parents: *id012 + sm_links: *id013 +- block_parents: *id014 + sm_links: *id013 +- block_parents: *id015 + sm_links: *id013 +- block_parents: *id011 + sm_links: &id016 + - [0, 1] + - [0, 2] + - [2, 3] +- block_parents: *id012 + sm_links: *id016 +- block_parents: *id014 + sm_links: *id016 +- block_parents: *id015 + sm_links: *id016 +- block_parents: &id018 [0, 0, 0, 0] + sm_links: &id017 + - [0, 1] + - [0, 2] + - [0, 3] + - [0, 4] +- block_parents: &id019 [0, 0, 1, 0] + sm_links: *id017 +- block_parents: &id021 [0, 0, 0, 1] + sm_links: *id017 +- block_parents: &id022 [0, 0, 1, 1] + sm_links: *id017 +- block_parents: *id018 + sm_links: &id020 + - [0, 1] + - [0, 2] + - [0, 3] + - [1, 4] +- block_parents: *id019 + sm_links: *id020 +- block_parents: *id021 + sm_links: *id020 +- block_parents: *id022 + sm_links: *id020 +- block_parents: *id018 + sm_links: &id023 + - [0, 1] + - [0, 2] + - [0, 3] + - [2, 4] +- block_parents: *id019 + sm_links: *id023 +- block_parents: *id021 + sm_links: *id023 +- block_parents: *id022 + sm_links: *id023 +- block_parents: *id018 + sm_links: &id024 + - [0, 1] + - [0, 2] + - [0, 3] + - [3, 4] +- block_parents: *id019 + sm_links: *id024 +- block_parents: *id021 + sm_links: *id024 +- block_parents: *id022 + sm_links: *id024 +- block_parents: *id018 + sm_links: &id025 + - [0, 1] + - [0, 2] + - [1, 3] + - [1, 4] +- block_parents: *id019 + sm_links: *id025 +- block_parents: *id021 + sm_links: *id025 +- block_parents: *id022 + sm_links: *id025 +- block_parents: *id018 + sm_links: &id026 + - [0, 1] + - [0, 2] + - [1, 3] + - [2, 4] +- block_parents: *id019 + sm_links: *id026 +- block_parents: *id021 + sm_links: *id026 +- block_parents: *id022 + sm_links: *id026 +- block_parents: *id018 + sm_links: &id027 + - [0, 1] + - [0, 2] + - [1, 3] + - [3, 4] +- block_parents: *id019 + sm_links: *id027 +- block_parents: *id021 + sm_links: *id027 +- block_parents: *id022 + sm_links: *id027 +- block_parents: *id018 + sm_links: &id028 + - [0, 1] + - [0, 2] + - [2, 3] + - [2, 4] +- block_parents: *id019 + sm_links: *id028 +- block_parents: *id021 + sm_links: *id028 +- block_parents: *id022 + sm_links: *id028 +- block_parents: *id018 + sm_links: &id029 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: *id019 + sm_links: *id029 +- block_parents: *id021 + sm_links: *id029 +- block_parents: *id022 + sm_links: *id029 diff --git a/tests/generators/fork_choice_generated/sample_invalid_messages.yaml b/tests/generators/fork_choice_generated/sample_invalid_messages.yaml new file mode 100644 index 0000000000..a3f0669faa --- /dev/null +++ b/tests/generators/fork_choice_generated/sample_invalid_messages.yaml @@ -0,0 +1,153 @@ +- block_parents: [0, 0, 1, 2, 3, 4, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0] + sm_links: &id001 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 3, 3, 2, 2, 1, 1, 0, 0] + sm_links: *id001 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 3, 3, 2, 2, 1, 1, 0, 0] + sm_links: *id001 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 3, 2, 2, 1, 1, 0, 0] + sm_links: *id001 +- block_parents: &id003 [0, 0, 0, 0] + sm_links: &id002 + - [0, 1] + - [0, 2] + - [0, 3] +- block_parents: &id004 [0, 0, 1, 0] + sm_links: *id002 +- block_parents: &id006 [0, 0, 0, 1] + sm_links: *id002 +- block_parents: &id007 [0, 0, 1, 1] + sm_links: *id002 +- block_parents: *id003 + sm_links: &id005 + - [0, 1] + - [0, 2] + - [1, 3] +- block_parents: *id004 + sm_links: *id005 +- block_parents: *id006 + sm_links: *id005 +- block_parents: *id007 + sm_links: *id005 +- block_parents: *id003 + sm_links: &id008 + - [0, 1] + - [0, 2] + - [2, 3] +- block_parents: *id004 + sm_links: *id008 +- block_parents: *id006 + sm_links: *id008 +- block_parents: *id007 + sm_links: *id008 +- block_parents: &id010 [0, 0, 0, 0] + sm_links: &id009 + - [0, 1] + - [0, 2] + - [0, 3] + - [0, 4] +- block_parents: &id011 [0, 0, 1, 0] + sm_links: *id009 +- block_parents: &id013 [0, 0, 0, 1] + sm_links: *id009 +- block_parents: &id014 [0, 0, 1, 1] + sm_links: *id009 +- block_parents: *id010 + sm_links: &id012 + - [0, 1] + - [0, 2] + - [0, 3] + - [1, 4] +- block_parents: *id011 + sm_links: *id012 +- block_parents: *id013 + sm_links: *id012 +- block_parents: *id014 + sm_links: *id012 +- block_parents: *id010 + sm_links: &id015 + - [0, 1] + - [0, 2] + - [0, 3] + - [2, 4] +- block_parents: *id011 + sm_links: *id015 +- block_parents: *id013 + sm_links: *id015 +- block_parents: *id014 + sm_links: *id015 +- block_parents: *id010 + sm_links: &id016 + - [0, 1] + - [0, 2] + - [0, 3] + - [3, 4] +- block_parents: *id011 + sm_links: *id016 +- block_parents: *id013 + sm_links: *id016 +- block_parents: *id014 + sm_links: *id016 +- block_parents: *id010 + sm_links: &id017 + - [0, 1] + - [0, 2] + - [1, 3] + - [1, 4] +- block_parents: *id011 + sm_links: *id017 +- block_parents: *id013 + sm_links: *id017 +- block_parents: *id014 + sm_links: *id017 +- block_parents: *id010 + sm_links: &id018 + - [0, 1] + - [0, 2] + - [1, 3] + - [2, 4] +- block_parents: *id011 + sm_links: *id018 +- block_parents: *id013 + sm_links: *id018 +- block_parents: *id014 + sm_links: *id018 +- block_parents: *id010 + sm_links: &id019 + - [0, 1] + - [0, 2] + - [1, 3] + - [3, 4] +- block_parents: *id011 + sm_links: *id019 +- block_parents: *id013 + sm_links: *id019 +- block_parents: *id014 + sm_links: *id019 +- block_parents: *id010 + sm_links: &id020 + - [0, 1] + - [0, 2] + - [2, 3] + - [2, 4] +- block_parents: *id011 + sm_links: *id020 +- block_parents: *id013 + sm_links: *id020 +- block_parents: *id014 + sm_links: *id020 +- block_parents: *id010 + sm_links: &id021 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: *id011 + sm_links: *id021 +- block_parents: *id013 + sm_links: *id021 +- block_parents: *id014 + sm_links: *id021 diff --git a/tests/generators/fork_choice_generated/scheduler.py b/tests/generators/fork_choice_generated/scheduler.py new file mode 100644 index 0000000000..fa32acaf41 --- /dev/null +++ b/tests/generators/fork_choice_generated/scheduler.py @@ -0,0 +1,123 @@ +from dataclasses import dataclass, field + + +@dataclass(order=True, init=False) +class QueueItem: + effective_slot: int + is_attestation: bool + message: object = field(compare=False) + dependencies: list = field(compare=False) + is_from_block: bool = field(compare=False) + + def __init__(self, message, is_attestation, is_from_block=False): + self.message = message + self.is_attestation = is_attestation + if is_attestation: + data = message.data + self.effective_slot = data.slot + 1 + self.dependencies = [data.beacon_block_root, data.target.root] + self.is_from_block = is_from_block + else: + block = message.message + self.effective_slot = block.slot + self.dependencies = [block.parent_root] + self.is_from_block = False + + +class MessageScheduler: + def __init__(self, spec, store): + self.spec = spec + self.store = store + self.message_queue = [] + + def is_early_message(self, item: QueueItem) -> bool: + current_slot = self.spec.get_current_slot(self.store) + return item.effective_slot < current_slot or any(root not in self.store.blocks for root in item.dependencies) + + def enque_message(self, item: QueueItem): + self.message_queue.append(item) + + def drain_queue(self, ) -> list[QueueItem]: + messages = self.message_queue[:] + self.message_queue.clear() + return messages + + def process_queue(self) -> tuple[bool, list]: + applied_events = [] + updated = False + for item in self.drain_queue(): + if self.is_early_message(item): + self.enque_message(item) + else: + if item.is_attestation: + if self.process_attestation(item.message): + applied_events.append(('attestation', item.message, True)) + else: + updated_, events_ = self.process_block(item.message, recovery=True) + if updated_: + updated = True + applied_events.extend(events_) + assert ('block', item.message, True) in events_ + return updated, applied_events + + def purge_queue(self) -> list: + applied_events = [] + while True: + updated, events = self.process_queue() + applied_events.extend(events) + if updated: + continue + else: + return applied_events + + def process_tick(self, time) -> list: + applied_events = [] + SECONDS_PER_SLOT = self.spec.config.SECONDS_PER_SLOT + assert time >= self.store.time + tick_slot = (time - self.store.genesis_time) // SECONDS_PER_SLOT + while self.spec.get_current_slot(self.store) < tick_slot: + previous_time = self.store.genesis_time + (self.spec.get_current_slot(self.store) + 1) * SECONDS_PER_SLOT + self.spec.on_tick(self.store, previous_time) + applied_events.append(('tick', previous_time, self.spec.get_current_slot(self.store) < tick_slot)) + applied_events.extend(self.purge_queue()) + return applied_events + + def process_attestation(self, attestation, is_from_block=False): + try: + self.spec.on_attestation(self.store, attestation, is_from_block) + return True + except AssertionError: + item = QueueItem(attestation, True, is_from_block) + if self.is_early_message(item): + self.enque_message(item) + return False + + def process_slashing(self, slashing): + try: + self.spec.on_attester_slashing(self.store, slashing) + return True + except AssertionError: + return False + + def process_block_messages(self, signed_block): + block = signed_block.message + for attestation in block.body.attestations: + self.process_attestation(attestation, is_from_block=True) + for attester_slashing in block.body.attester_slashings: + self.process_slashing(attester_slashing) + + def process_block(self, signed_block, recovery=False) -> tuple[bool, list]: + applied_events = [] + try: + self.spec.on_block(self.store, signed_block) + valid = True + applied_events.append(('block', signed_block, recovery)) + except AssertionError: + item = QueueItem(signed_block, False) + if self.is_early_message(item): + self.enque_message(item) + valid = False + if valid: + applied_events.extend(self.purge_queue()) + self.process_block_messages(signed_block) + return valid, applied_events diff --git a/tests/generators/fork_choice_generated/small/block_cover.yaml b/tests/generators/fork_choice_generated/small/block_cover.yaml new file mode 100644 index 0000000000..6f8ad60ce6 --- /dev/null +++ b/tests/generators/fork_choice_generated/small/block_cover.yaml @@ -0,0 +1,216 @@ +- block_epochs: [0] + current_epoch: 1 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: true} + previous_justifications: [false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0] + current_epoch: 1 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: true} + previous_justifications: [false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1] + current_epoch: 1 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: true} + previous_justifications: [false, false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1, 1] + current_epoch: 1 + current_justifications: [false, false, false] + parents: [0, 0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: true} + previous_justifications: [false, false, false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0] + current_epoch: 3 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: true} + previous_justifications: [false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0] + current_epoch: 3 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: true} + previous_justifications: [false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1] + current_epoch: 3 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: true} + previous_justifications: [false, false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1] + current_epoch: 3 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: true} + previous_justifications: [false, true] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [2] + current_epoch: 3 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2] + current_epoch: 3 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 3 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3, 3] + current_epoch: 3 + current_justifications: [false, false, false] + parents: [0, 0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2] + current_epoch: 5 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2] + current_epoch: 5 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 5 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3, 3] + current_epoch: 5 + current_justifications: [false, false, false] + parents: [0, 0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3, 3] + current_epoch: 4 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 3 + target_block: 1 +- block_epochs: [2, 3, 3] + current_epoch: 4 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false, true] + store_justified_epoch: 3 + target_block: 1 +- block_epochs: [2, 3] + current_epoch: 4 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 3 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 4 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, true] + store_justified_epoch: 3 + target_block: 0 +- block_epochs: [2, 3, 3] + current_epoch: 5 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 3 + target_block: 1 +- block_epochs: [2, 3, 3] + current_epoch: 5 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false, true] + store_justified_epoch: 3 + target_block: 1 +- block_epochs: [2, 3] + current_epoch: 5 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 3 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 5 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, true] + store_justified_epoch: 3 + target_block: 0 diff --git a/tests/generators/fork_choice_generated/small/block_tree_other.yaml b/tests/generators/fork_choice_generated/small/block_tree_other.yaml new file mode 100644 index 0000000000..e39c4ebc06 --- /dev/null +++ b/tests/generators/fork_choice_generated/small/block_tree_other.yaml @@ -0,0 +1,12 @@ +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0] + sm_links: &id001 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 3, 2, 1, 0] + sm_links: *id001 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 2, 1, 0] + sm_links: *id001 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 3, 2, 1, 0] + sm_links: *id001 diff --git a/tests/generators/fork_choice_generated/small/block_tree_tree.yaml b/tests/generators/fork_choice_generated/small/block_tree_tree.yaml new file mode 100644 index 0000000000..a2a58b7eae --- /dev/null +++ b/tests/generators/fork_choice_generated/small/block_tree_tree.yaml @@ -0,0 +1,312 @@ +- block_parents: &id002 [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1, 0] + sm_links: &id001 + - [0, 1] + - [0, 2] + - [0, 3] +- block_parents: &id003 [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 5, 4, 3, 2, 1, 0] + sm_links: *id001 +- block_parents: *id002 + sm_links: &id004 + - [0, 1] + - [0, 2] + - [0, 4] +- block_parents: *id003 + sm_links: *id004 +- block_parents: *id002 + sm_links: &id005 + - [0, 1] + - [0, 2] + - [1, 3] +- block_parents: *id003 + sm_links: *id005 +- block_parents: *id002 + sm_links: &id006 + - [0, 1] + - [0, 2] + - [2, 3] +- block_parents: *id003 + sm_links: *id006 +- block_parents: *id002 + sm_links: &id007 + - [0, 1] + - [0, 2] + - [1, 4] +- block_parents: *id003 + sm_links: *id007 +- block_parents: *id002 + sm_links: &id008 + - [0, 1] + - [0, 2] + - [2, 4] +- block_parents: *id003 + sm_links: *id008 +- block_parents: *id002 + sm_links: &id009 + - [0, 1] + - [0, 3] + - [0, 4] +- block_parents: *id003 + sm_links: *id009 +- block_parents: *id002 + sm_links: &id010 + - [0, 2] + - [0, 3] + - [0, 4] +- block_parents: *id003 + sm_links: *id010 +- block_parents: *id002 + sm_links: &id011 + - [0, 1] + - [0, 3] + - [1, 4] +- block_parents: *id003 + sm_links: *id011 +- block_parents: *id002 + sm_links: &id012 + - [0, 1] + - [0, 3] + - [3, 4] +- block_parents: *id003 + sm_links: *id012 +- block_parents: *id002 + sm_links: &id013 + - [0, 2] + - [0, 3] + - [2, 4] +- block_parents: *id003 + sm_links: *id013 +- block_parents: *id002 + sm_links: &id014 + - [0, 2] + - [0, 3] + - [3, 4] +- block_parents: *id003 + sm_links: *id014 +- block_parents: *id002 + sm_links: &id015 + - [0, 1] + - [1, 3] + - [1, 4] +- block_parents: *id003 + sm_links: *id015 +- block_parents: *id002 + sm_links: &id016 + - [0, 1] + - [1, 3] + - [3, 4] +- block_parents: *id003 + sm_links: *id016 +- block_parents: *id002 + sm_links: &id017 + - [0, 2] + - [2, 3] + - [2, 4] +- block_parents: *id003 + sm_links: *id017 +- block_parents: *id002 + sm_links: &id018 + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: *id003 + sm_links: *id018 +- block_parents: [0, 0, 1, 0, 0] + sm_links: &id019 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: [0, 0, 0, 1, 0] + sm_links: *id019 +- block_parents: [0, 0, 1, 1, 0] + sm_links: *id019 +- block_parents: [0, 0, 0, 2, 0] + sm_links: *id019 +- block_parents: [0, 0, 1, 2, 0] + sm_links: *id019 +- block_parents: [0, 0, 0, 0, 1] + sm_links: *id019 +- block_parents: [0, 0, 1, 0, 1] + sm_links: *id019 +- block_parents: [0, 0, 0, 1, 1] + sm_links: *id019 +- block_parents: [0, 0, 1, 1, 1] + sm_links: *id019 +- block_parents: [0, 0, 0, 2, 1] + sm_links: *id019 +- block_parents: [0, 0, 1, 2, 1] + sm_links: *id019 +- block_parents: [0, 0, 0, 0, 2] + sm_links: *id019 +- block_parents: [0, 0, 1, 0, 2] + sm_links: *id019 +- block_parents: [0, 0, 0, 1, 2] + sm_links: *id019 +- block_parents: [0, 0, 1, 1, 2] + sm_links: *id019 +- block_parents: [0, 0, 0, 2, 2] + sm_links: *id019 +- block_parents: [0, 0, 1, 2, 2] + sm_links: *id019 +- block_parents: [0, 0, 0, 0, 3] + sm_links: *id019 +- block_parents: [0, 0, 1, 0, 3] + sm_links: *id019 +- block_parents: [0, 0, 0, 1, 3] + sm_links: *id019 +- block_parents: [0, 0, 1, 1, 3] + sm_links: *id019 +- block_parents: [0, 0, 0, 2, 3] + sm_links: *id019 +- block_parents: [0, 0, 1, 2, 3] + sm_links: *id019 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0] + sm_links: &id020 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 3, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 3, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 4, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 4, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 4, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 4, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 4, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 4, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 3, 5, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 4, 5, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 4, 5, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 3, 6, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 4, 6, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 4, 6, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 3, 7, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 4, 7, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 4, 7, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 2, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 2, 3, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 2, 3, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 2, 3, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 2, 3, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 2, 3, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 4, 3, 3, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 2, 4, 4, 5, 3, 3, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 5, 3, 3, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 2, 4, 4, 6, 3, 3, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 6, 3, 3, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 2, 4, 3, 1, 0] + sm_links: *id020 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 3, 4, 3, 1, 0] + sm_links: *id020 diff --git a/tests/generators/fork_choice_generated/small/block_tree_tree_2.yaml b/tests/generators/fork_choice_generated/small/block_tree_tree_2.yaml new file mode 100644 index 0000000000..907dcd18fd --- /dev/null +++ b/tests/generators/fork_choice_generated/small/block_tree_tree_2.yaml @@ -0,0 +1,1252 @@ +- block_parents: &id002 [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1, 0] + sm_links: &id001 + - [0, 1] + - [0, 2] + - [0, 3] + - [0, 4] +- block_parents: &id003 [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 5, 4, 3, 2, 1, 0] + sm_links: *id001 +- block_parents: *id002 + sm_links: &id004 + - [0, 1] + - [0, 2] + - [0, 3] + - [0, 5] +- block_parents: *id003 + sm_links: *id004 +- block_parents: *id002 + sm_links: &id005 + - [0, 1] + - [0, 2] + - [0, 3] + - [1, 4] +- block_parents: *id003 + sm_links: *id005 +- block_parents: *id002 + sm_links: &id006 + - [0, 1] + - [0, 2] + - [0, 3] + - [2, 4] +- block_parents: *id003 + sm_links: *id006 +- block_parents: *id002 + sm_links: &id007 + - [0, 1] + - [0, 2] + - [0, 3] + - [3, 4] +- block_parents: *id003 + sm_links: *id007 +- block_parents: *id002 + sm_links: &id008 + - [0, 1] + - [0, 2] + - [0, 3] + - [1, 5] +- block_parents: *id003 + sm_links: *id008 +- block_parents: *id002 + sm_links: &id009 + - [0, 1] + - [0, 2] + - [0, 3] + - [2, 5] +- block_parents: *id003 + sm_links: *id009 +- block_parents: *id002 + sm_links: &id010 + - [0, 1] + - [0, 2] + - [0, 3] + - [3, 5] +- block_parents: *id003 + sm_links: *id010 +- block_parents: *id002 + sm_links: &id011 + - [0, 1] + - [0, 2] + - [1, 3] + - [1, 4] +- block_parents: *id003 + sm_links: *id011 +- block_parents: *id002 + sm_links: &id012 + - [0, 1] + - [0, 2] + - [1, 3] + - [2, 4] +- block_parents: *id003 + sm_links: *id012 +- block_parents: *id002 + sm_links: &id013 + - [0, 1] + - [0, 2] + - [1, 3] + - [3, 4] +- block_parents: *id003 + sm_links: *id013 +- block_parents: *id002 + sm_links: &id014 + - [0, 1] + - [0, 2] + - [1, 3] + - [1, 5] +- block_parents: *id003 + sm_links: *id014 +- block_parents: *id002 + sm_links: &id015 + - [0, 1] + - [0, 2] + - [1, 3] + - [2, 5] +- block_parents: *id003 + sm_links: *id015 +- block_parents: *id002 + sm_links: &id016 + - [0, 1] + - [0, 2] + - [1, 3] + - [3, 5] +- block_parents: *id003 + sm_links: *id016 +- block_parents: *id002 + sm_links: &id017 + - [0, 1] + - [0, 2] + - [2, 3] + - [2, 4] +- block_parents: *id003 + sm_links: *id017 +- block_parents: *id002 + sm_links: &id018 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: *id003 + sm_links: *id018 +- block_parents: *id002 + sm_links: &id019 + - [0, 1] + - [0, 2] + - [2, 3] + - [2, 5] +- block_parents: *id003 + sm_links: *id019 +- block_parents: *id002 + sm_links: &id020 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 5] +- block_parents: *id003 + sm_links: *id020 +- block_parents: *id002 + sm_links: &id021 + - [0, 1] + - [0, 2] + - [0, 4] + - [0, 5] +- block_parents: *id003 + sm_links: *id021 +- block_parents: *id002 + sm_links: &id022 + - [0, 1] + - [0, 2] + - [0, 4] + - [1, 5] +- block_parents: *id003 + sm_links: *id022 +- block_parents: *id002 + sm_links: &id023 + - [0, 1] + - [0, 2] + - [0, 4] + - [2, 5] +- block_parents: *id003 + sm_links: *id023 +- block_parents: *id002 + sm_links: &id024 + - [0, 1] + - [0, 2] + - [0, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id024 +- block_parents: *id002 + sm_links: &id025 + - [0, 1] + - [0, 2] + - [1, 4] + - [1, 5] +- block_parents: *id003 + sm_links: *id025 +- block_parents: *id002 + sm_links: &id026 + - [0, 1] + - [0, 2] + - [1, 4] + - [2, 5] +- block_parents: *id003 + sm_links: *id026 +- block_parents: *id002 + sm_links: &id027 + - [0, 1] + - [0, 2] + - [1, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id027 +- block_parents: *id002 + sm_links: &id028 + - [0, 1] + - [0, 2] + - [2, 4] + - [2, 5] +- block_parents: *id003 + sm_links: *id028 +- block_parents: *id002 + sm_links: &id029 + - [0, 1] + - [0, 2] + - [2, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id029 +- block_parents: *id002 + sm_links: &id030 + - [0, 1] + - [0, 3] + - [0, 4] + - [0, 5] +- block_parents: *id003 + sm_links: *id030 +- block_parents: *id002 + sm_links: &id031 + - [0, 2] + - [0, 3] + - [0, 4] + - [0, 5] +- block_parents: *id003 + sm_links: *id031 +- block_parents: *id002 + sm_links: &id032 + - [0, 1] + - [0, 3] + - [0, 4] + - [1, 5] +- block_parents: *id003 + sm_links: *id032 +- block_parents: *id002 + sm_links: &id033 + - [0, 1] + - [0, 3] + - [0, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id033 +- block_parents: *id002 + sm_links: &id034 + - [0, 1] + - [0, 3] + - [0, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id034 +- block_parents: *id002 + sm_links: &id035 + - [0, 2] + - [0, 3] + - [0, 4] + - [2, 5] +- block_parents: *id003 + sm_links: *id035 +- block_parents: *id002 + sm_links: &id036 + - [0, 2] + - [0, 3] + - [0, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id036 +- block_parents: *id002 + sm_links: &id037 + - [0, 2] + - [0, 3] + - [0, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id037 +- block_parents: *id002 + sm_links: &id038 + - [0, 1] + - [0, 3] + - [1, 4] + - [1, 5] +- block_parents: *id003 + sm_links: *id038 +- block_parents: *id002 + sm_links: &id039 + - [0, 1] + - [0, 3] + - [1, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id039 +- block_parents: *id002 + sm_links: &id040 + - [0, 1] + - [0, 3] + - [1, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id040 +- block_parents: *id002 + sm_links: &id041 + - [0, 1] + - [0, 3] + - [3, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id041 +- block_parents: *id002 + sm_links: &id042 + - [0, 1] + - [0, 3] + - [3, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id042 +- block_parents: *id002 + sm_links: &id043 + - [0, 2] + - [0, 3] + - [2, 4] + - [2, 5] +- block_parents: *id003 + sm_links: *id043 +- block_parents: *id002 + sm_links: &id044 + - [0, 2] + - [0, 3] + - [2, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id044 +- block_parents: *id002 + sm_links: &id045 + - [0, 2] + - [0, 3] + - [2, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id045 +- block_parents: *id002 + sm_links: &id046 + - [0, 2] + - [0, 3] + - [3, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id046 +- block_parents: *id002 + sm_links: &id047 + - [0, 2] + - [0, 3] + - [3, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id047 +- block_parents: *id002 + sm_links: &id048 + - [0, 1] + - [1, 3] + - [1, 4] + - [1, 5] +- block_parents: *id003 + sm_links: *id048 +- block_parents: *id002 + sm_links: &id049 + - [0, 1] + - [1, 3] + - [1, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id049 +- block_parents: *id002 + sm_links: &id050 + - [0, 1] + - [1, 3] + - [1, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id050 +- block_parents: *id002 + sm_links: &id051 + - [0, 1] + - [1, 3] + - [3, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id051 +- block_parents: *id002 + sm_links: &id052 + - [0, 1] + - [1, 3] + - [3, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id052 +- block_parents: *id002 + sm_links: &id053 + - [0, 2] + - [2, 3] + - [2, 4] + - [2, 5] +- block_parents: *id003 + sm_links: *id053 +- block_parents: *id002 + sm_links: &id054 + - [0, 2] + - [2, 3] + - [2, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id054 +- block_parents: *id002 + sm_links: &id055 + - [0, 2] + - [2, 3] + - [2, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id055 +- block_parents: *id002 + sm_links: &id056 + - [0, 2] + - [2, 3] + - [3, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id056 +- block_parents: *id002 + sm_links: &id057 + - [0, 2] + - [2, 3] + - [3, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id057 +- block_parents: [0, 0, 1, 0, 0, 0] + sm_links: &id058 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: [0, 0, 0, 1, 0, 0] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 0, 0] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 0, 0] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 0, 0] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 1, 0] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 1, 0] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 1, 0] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 1, 0] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 1, 0] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 1, 0] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 2, 0] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 2, 0] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 2, 0] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 2, 0] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 2, 0] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 2, 0] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 3, 0] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 3, 0] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 3, 0] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 3, 0] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 3, 0] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 3, 0] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 0, 1] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 0, 1] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 0, 1] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 0, 1] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 0, 1] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 0, 1] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 1, 1] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 1, 1] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 1, 1] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 1, 1] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 1, 1] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 1, 1] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 2, 1] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 2, 1] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 2, 1] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 2, 1] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 2, 1] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 2, 1] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 3, 1] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 3, 1] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 3, 1] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 3, 1] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 3, 1] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 3, 1] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 0, 2] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 0, 2] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 0, 2] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 0, 2] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 0, 2] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 0, 2] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 1, 2] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 1, 2] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 1, 2] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 1, 2] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 1, 2] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 1, 2] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 2, 2] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 2, 2] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 2, 2] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 2, 2] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 2, 2] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 2, 2] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 3, 2] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 3, 2] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 3, 2] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 3, 2] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 3, 2] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 3, 2] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 0, 3] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 0, 3] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 0, 3] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 0, 3] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 0, 3] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 0, 3] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 1, 3] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 1, 3] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 1, 3] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 1, 3] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 1, 3] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 1, 3] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 2, 3] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 2, 3] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 2, 3] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 2, 3] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 2, 3] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 2, 3] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 3, 3] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 3, 3] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 3, 3] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 3, 3] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 3, 3] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 3, 3] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 0, 4] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 0, 4] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 0, 4] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 0, 4] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 0, 4] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 0, 4] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 1, 4] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 1, 4] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 1, 4] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 1, 4] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 1, 4] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 1, 4] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 2, 4] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 2, 4] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 2, 4] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 2, 4] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 2, 4] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 2, 4] + sm_links: *id058 +- block_parents: [0, 0, 0, 0, 3, 4] + sm_links: *id058 +- block_parents: [0, 0, 1, 0, 3, 4] + sm_links: *id058 +- block_parents: [0, 0, 0, 1, 3, 4] + sm_links: *id058 +- block_parents: [0, 0, 1, 1, 3, 4] + sm_links: *id058 +- block_parents: [0, 0, 0, 2, 3, 4] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 3, 4] + sm_links: *id058 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0] + sm_links: &id059 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 3, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 3, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 4, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 4, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 4, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 4, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 4, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 4, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 3, 5, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 4, 5, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 4, 5, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 3, 6, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 4, 6, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 4, 6, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 3, 7, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 4, 7, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 4, 7, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 2, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 2, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 2, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 2, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 2, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 2, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 4, 3, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 4, 5, 3, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 5, 3, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 4, 6, 3, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 6, 3, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 2, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 3, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 4, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 4, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 2, 5, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 3, 5, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 4, 5, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 4, 5, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 5, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 5, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 5, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 2, 6, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 3, 6, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 4, 6, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 4, 6, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 6, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 6, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 6, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 2, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 2, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 4, 3, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 3, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 2, 4, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 3, 4, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 4, 4, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 4, 4, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 4, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 4, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 4, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 2, 5, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 3, 5, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 4, 5, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 4, 5, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 4, 5, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 2, 6, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 3, 6, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 4, 6, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 4, 6, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 4, 6, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 6, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 6, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 6, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 2, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 2, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 4, 3, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 3, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 2, 4, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 3, 4, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 4, 4, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 4, 4, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 4, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 4, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 4, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 2, 5, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 3, 5, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 4, 5, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 4, 5, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 4, 5, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 5, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 5, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 5, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 2, 6, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 3, 6, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 4, 6, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 4, 6, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 4, 6, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 6, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 6, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 6, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 2, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 2, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 4, 3, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 3, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 2, 4, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 3, 4, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 4, 4, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 4, 4, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 4, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 4, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 4, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 2, 5, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 3, 5, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 4, 5, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 4, 5, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 4, 5, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 5, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 5, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 5, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 2, 6, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 3, 6, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 4, 6, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 4, 6, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 4, 6, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 6, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 6, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 6, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 2, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 2, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 2, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 2, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 2, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 2, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 2, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 2, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 2, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 2, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 2, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 3, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 4, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 4, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 2, 5, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 3, 5, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 4, 5, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 4, 5, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 5, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 5, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 5, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 2, 6, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 3, 6, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 4, 6, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 4, 6, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 6, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 6, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 6, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 2, 4, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 3, 4, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 3, 4, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 2, 5, 4, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 3, 5, 4, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 3, 5, 4, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 5, 4, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 5, 4, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 2, 6, 4, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 3, 6, 4, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 3, 6, 4, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 6, 4, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 6, 4, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 2, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 2, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 2, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 2, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 2, 3, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 3, 3, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 4, 3, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 4, 3, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 3, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 3, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 3, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 2, 4, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 3, 4, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 3, 4, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 4, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 4, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 2, 5, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 2, 5, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 3, 5, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 3, 5, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 3, 5, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 4, 5, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 4, 5, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 2, 6, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 2, 6, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 3, 6, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 3, 6, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 3, 6, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 4, 6, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 4, 6, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 6, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 6, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 6, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 2, 6, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 2, 6, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 2, 6, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 2, 6, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 2, 3, 6, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 3, 3, 6, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 4, 3, 6, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 4, 3, 6, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 5, 3, 6, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 3, 5, 3, 6, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 2, 4, 5, 3, 6, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 3, 2, 4, 6, 4, 1, 0] + sm_links: *id059 +- block_parents: [0, 0, 1, 2, 3, 2, 3, 4, 6, 4, 1, 0] + sm_links: *id059 diff --git a/tests/generators/fork_choice_generated/small/test_gen.yaml b/tests/generators/fork_choice_generated/small/test_gen.yaml new file mode 100644 index 0000000000..800d025892 --- /dev/null +++ b/tests/generators/fork_choice_generated/small/test_gen.yaml @@ -0,0 +1,38 @@ +block_tree_test: + test_type: block_tree + instances: small/block_tree_tree.yaml # 128 + seed: 123 + nr_variations: 2 + nr_mutations: 1 +block_weight_test: + test_type: block_tree + instances: small/block_tree_other.yaml # 4 + seed: 123 + nr_variations: 32 + nr_mutations: 1 +shuffling_test: + test_type: block_tree + instances: small/block_tree_other.yaml # 4 + seed: 123 + nr_variations: 2 + nr_mutations: 31 +attester_slashing_test: + test_type: block_tree + instances: small/block_tree_other.yaml # 4 + seed: 123 + nr_variations: 8 + nr_mutations: 3 + with_attester_slashings: true +invalid_message_test: + test_type: block_tree + instances: small/block_tree_other.yaml # 4 + seed: 123 + nr_variations: 16 + nr_mutations: 1 + with_invalid_messages: true +block_cover_test: + test_type: block_cover + instances: small/block_cover.yaml # 24 + seed: 456 + nr_variations: 2 + nr_mutations: 3 diff --git a/tests/generators/fork_choice_generated/standard/block_cover.yaml b/tests/generators/fork_choice_generated/standard/block_cover.yaml new file mode 100644 index 0000000000..331079855a --- /dev/null +++ b/tests/generators/fork_choice_generated/standard/block_cover.yaml @@ -0,0 +1,540 @@ +- block_epochs: [0] + current_epoch: 1 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: true} + previous_justifications: [false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0] + current_epoch: 1 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: true} + previous_justifications: [false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0] + current_epoch: 1 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: true} + previous_justifications: [false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0] + current_epoch: 1 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: true} + previous_justifications: [false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0] + current_epoch: 1 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: true} + previous_justifications: [false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1] + current_epoch: 1 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: true} + previous_justifications: [false, false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1, 1] + current_epoch: 1 + current_justifications: [false, false, false] + parents: [0, 0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: true} + previous_justifications: [false, false, false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1, 1, 1] + current_epoch: 1 + current_justifications: [false, false, false, false] + parents: [0, 0, 0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: true} + previous_justifications: [false, false, false, false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1, 1, 1, 1] + current_epoch: 1 + current_justifications: [false, false, false, false, false] + parents: [0, 0, 0, 0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: true} + previous_justifications: [false, false, false, false, false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1] + current_epoch: 1 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: true} + previous_justifications: [false, true] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0] + current_epoch: 3 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: true} + previous_justifications: [false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0] + current_epoch: 3 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: true} + previous_justifications: [false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0] + current_epoch: 3 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: true} + previous_justifications: [false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0] + current_epoch: 3 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: true} + previous_justifications: [false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0] + current_epoch: 3 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: true} + previous_justifications: [false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1] + current_epoch: 3 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: true} + previous_justifications: [false, false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1] + current_epoch: 3 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: true} + previous_justifications: [false, true] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1, 1] + current_epoch: 3 + current_justifications: [false, false, false] + parents: [0, 0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: true} + previous_justifications: [false, false, false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1, 1] + current_epoch: 3 + current_justifications: [false, false, false] + parents: [0, 0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: true} + previous_justifications: [false, true, false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1, 1, 1] + current_epoch: 3 + current_justifications: [false, false, false, false] + parents: [0, 0, 0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: true} + previous_justifications: [false, false, false, false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [2] + current_epoch: 3 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2] + current_epoch: 3 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2] + current_epoch: 3 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2] + current_epoch: 3 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2] + current_epoch: 3 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 3 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3, 3] + current_epoch: 3 + current_justifications: [false, false, false] + parents: [0, 0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3, 3, 3] + current_epoch: 3 + current_justifications: [false, false, false, false] + parents: [0, 0, 0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false, false, false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3, 3, 3, 3] + current_epoch: 3 + current_justifications: [false, false, false, false, false] + parents: [0, 0, 0, 0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false, false, false, false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 3 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, true] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2] + current_epoch: 5 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2] + current_epoch: 5 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2] + current_epoch: 5 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2] + current_epoch: 5 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2] + current_epoch: 5 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 5 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3, 3] + current_epoch: 5 + current_justifications: [false, false, false] + parents: [0, 0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3, 3, 3] + current_epoch: 5 + current_justifications: [false, false, false, false] + parents: [0, 0, 0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false, false, false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3, 3, 3, 3] + current_epoch: 5 + current_justifications: [false, false, false, false, false] + parents: [0, 0, 0, 0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false, false, false, false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 5 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3, 3] + current_epoch: 4 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 3 + target_block: 1 +- block_epochs: [2, 3, 3] + current_epoch: 4 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false, true] + store_justified_epoch: 3 + target_block: 1 +- block_epochs: [2, 3, 3] + current_epoch: 4 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 3 + target_block: 1 +- block_epochs: [2, 3, 3] + current_epoch: 4 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false, true] + store_justified_epoch: 3 + target_block: 1 +- block_epochs: [2, 3, 3] + current_epoch: 4 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 3 + target_block: 1 +- block_epochs: [2, 3] + current_epoch: 4 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 3 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 4 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, true] + store_justified_epoch: 3 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 4 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 3 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 4 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, true] + store_justified_epoch: 3 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 4 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 3 + target_block: 0 +- block_epochs: [2, 3, 3] + current_epoch: 5 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 3 + target_block: 1 +- block_epochs: [2, 3, 3] + current_epoch: 5 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false, true] + store_justified_epoch: 3 + target_block: 1 +- block_epochs: [2, 3, 3] + current_epoch: 5 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 3 + target_block: 1 +- block_epochs: [2, 3, 3] + current_epoch: 5 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false, true] + store_justified_epoch: 3 + target_block: 1 +- block_epochs: [2, 3, 3] + current_epoch: 5 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 3 + target_block: 1 +- block_epochs: [2, 3] + current_epoch: 5 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 3 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 5 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, true] + store_justified_epoch: 3 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 5 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 3 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 5 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, true] + store_justified_epoch: 3 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 5 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 3 + target_block: 0 diff --git a/tests/generators/fork_choice_generated/standard/block_tree_other.yaml b/tests/generators/fork_choice_generated/standard/block_tree_other.yaml new file mode 100644 index 0000000000..ffdc7dc409 --- /dev/null +++ b/tests/generators/fork_choice_generated/standard/block_tree_other.yaml @@ -0,0 +1,20 @@ +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0] + sm_links: &id001 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 3, 2, 1, 0] + sm_links: *id001 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 2, 1, 0] + sm_links: *id001 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 3, 2, 1, 0] + sm_links: *id001 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 2, 1, 0] + sm_links: *id001 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 4, 2, 1, 0] + sm_links: *id001 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 4, 2, 1, 0] + sm_links: *id001 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 4, 2, 1, 0] + sm_links: *id001 diff --git a/tests/generators/fork_choice_generated/standard/block_tree_tree.yaml b/tests/generators/fork_choice_generated/standard/block_tree_tree.yaml new file mode 100644 index 0000000000..0a698b7aa7 --- /dev/null +++ b/tests/generators/fork_choice_generated/standard/block_tree_tree.yaml @@ -0,0 +1,2280 @@ +- block_parents: &id002 [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1, 0] + sm_links: &id001 + - [0, 1] + - [0, 2] + - [0, 3] + - [0, 4] +- block_parents: &id003 [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 5, 4, 3, 2, 1, 0] + sm_links: *id001 +- block_parents: &id005 [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 5, 4, 3, 2, 1, 0] + sm_links: *id001 +- block_parents: &id006 [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 5, 4, 3, 2, 1, 0] + sm_links: *id001 +- block_parents: &id007 [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 4, 3, 2, 1, 0] + sm_links: *id001 +- block_parents: *id002 + sm_links: &id004 + - [0, 1] + - [0, 2] + - [0, 3] + - [0, 5] +- block_parents: *id003 + sm_links: *id004 +- block_parents: *id005 + sm_links: *id004 +- block_parents: *id006 + sm_links: *id004 +- block_parents: *id007 + sm_links: *id004 +- block_parents: *id002 + sm_links: &id008 + - [0, 1] + - [0, 2] + - [0, 3] + - [1, 4] +- block_parents: *id003 + sm_links: *id008 +- block_parents: *id005 + sm_links: *id008 +- block_parents: *id006 + sm_links: *id008 +- block_parents: *id007 + sm_links: *id008 +- block_parents: *id002 + sm_links: &id009 + - [0, 1] + - [0, 2] + - [0, 3] + - [2, 4] +- block_parents: *id003 + sm_links: *id009 +- block_parents: *id005 + sm_links: *id009 +- block_parents: *id006 + sm_links: *id009 +- block_parents: *id007 + sm_links: *id009 +- block_parents: *id002 + sm_links: &id010 + - [0, 1] + - [0, 2] + - [0, 3] + - [3, 4] +- block_parents: *id003 + sm_links: *id010 +- block_parents: *id005 + sm_links: *id010 +- block_parents: *id006 + sm_links: *id010 +- block_parents: *id007 + sm_links: *id010 +- block_parents: *id002 + sm_links: &id011 + - [0, 1] + - [0, 2] + - [0, 3] + - [1, 5] +- block_parents: *id003 + sm_links: *id011 +- block_parents: *id005 + sm_links: *id011 +- block_parents: *id006 + sm_links: *id011 +- block_parents: *id007 + sm_links: *id011 +- block_parents: *id002 + sm_links: &id012 + - [0, 1] + - [0, 2] + - [0, 3] + - [2, 5] +- block_parents: *id003 + sm_links: *id012 +- block_parents: *id005 + sm_links: *id012 +- block_parents: *id006 + sm_links: *id012 +- block_parents: *id007 + sm_links: *id012 +- block_parents: *id002 + sm_links: &id013 + - [0, 1] + - [0, 2] + - [0, 3] + - [3, 5] +- block_parents: *id003 + sm_links: *id013 +- block_parents: *id005 + sm_links: *id013 +- block_parents: *id006 + sm_links: *id013 +- block_parents: *id007 + sm_links: *id013 +- block_parents: *id002 + sm_links: &id014 + - [0, 1] + - [0, 2] + - [1, 3] + - [1, 4] +- block_parents: *id003 + sm_links: *id014 +- block_parents: *id005 + sm_links: *id014 +- block_parents: *id006 + sm_links: *id014 +- block_parents: *id007 + sm_links: *id014 +- block_parents: *id002 + sm_links: &id015 + - [0, 1] + - [0, 2] + - [1, 3] + - [2, 4] +- block_parents: *id003 + sm_links: *id015 +- block_parents: *id005 + sm_links: *id015 +- block_parents: *id006 + sm_links: *id015 +- block_parents: *id007 + sm_links: *id015 +- block_parents: *id002 + sm_links: &id016 + - [0, 1] + - [0, 2] + - [1, 3] + - [3, 4] +- block_parents: *id003 + sm_links: *id016 +- block_parents: *id005 + sm_links: *id016 +- block_parents: *id006 + sm_links: *id016 +- block_parents: *id007 + sm_links: *id016 +- block_parents: *id002 + sm_links: &id017 + - [0, 1] + - [0, 2] + - [1, 3] + - [1, 5] +- block_parents: *id003 + sm_links: *id017 +- block_parents: *id005 + sm_links: *id017 +- block_parents: *id006 + sm_links: *id017 +- block_parents: *id007 + sm_links: *id017 +- block_parents: *id002 + sm_links: &id018 + - [0, 1] + - [0, 2] + - [1, 3] + - [2, 5] +- block_parents: *id003 + sm_links: *id018 +- block_parents: *id005 + sm_links: *id018 +- block_parents: *id006 + sm_links: *id018 +- block_parents: *id007 + sm_links: *id018 +- block_parents: *id002 + sm_links: &id019 + - [0, 1] + - [0, 2] + - [1, 3] + - [3, 5] +- block_parents: *id003 + sm_links: *id019 +- block_parents: *id005 + sm_links: *id019 +- block_parents: *id006 + sm_links: *id019 +- block_parents: *id007 + sm_links: *id019 +- block_parents: *id002 + sm_links: &id020 + - [0, 1] + - [0, 2] + - [2, 3] + - [2, 4] +- block_parents: *id003 + sm_links: *id020 +- block_parents: *id005 + sm_links: *id020 +- block_parents: *id006 + sm_links: *id020 +- block_parents: *id007 + sm_links: *id020 +- block_parents: *id002 + sm_links: &id021 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: *id003 + sm_links: *id021 +- block_parents: *id005 + sm_links: *id021 +- block_parents: *id006 + sm_links: *id021 +- block_parents: *id007 + sm_links: *id021 +- block_parents: *id002 + sm_links: &id022 + - [0, 1] + - [0, 2] + - [2, 3] + - [2, 5] +- block_parents: *id003 + sm_links: *id022 +- block_parents: *id005 + sm_links: *id022 +- block_parents: *id006 + sm_links: *id022 +- block_parents: *id007 + sm_links: *id022 +- block_parents: *id002 + sm_links: &id023 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 5] +- block_parents: *id003 + sm_links: *id023 +- block_parents: *id005 + sm_links: *id023 +- block_parents: *id006 + sm_links: *id023 +- block_parents: *id007 + sm_links: *id023 +- block_parents: *id002 + sm_links: &id024 + - [0, 1] + - [0, 2] + - [0, 4] + - [0, 5] +- block_parents: *id003 + sm_links: *id024 +- block_parents: *id005 + sm_links: *id024 +- block_parents: *id006 + sm_links: *id024 +- block_parents: *id007 + sm_links: *id024 +- block_parents: *id002 + sm_links: &id025 + - [0, 1] + - [0, 2] + - [0, 4] + - [1, 5] +- block_parents: *id003 + sm_links: *id025 +- block_parents: *id005 + sm_links: *id025 +- block_parents: *id006 + sm_links: *id025 +- block_parents: *id007 + sm_links: *id025 +- block_parents: *id002 + sm_links: &id026 + - [0, 1] + - [0, 2] + - [0, 4] + - [2, 5] +- block_parents: *id003 + sm_links: *id026 +- block_parents: *id005 + sm_links: *id026 +- block_parents: *id006 + sm_links: *id026 +- block_parents: *id007 + sm_links: *id026 +- block_parents: *id002 + sm_links: &id027 + - [0, 1] + - [0, 2] + - [0, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id027 +- block_parents: *id005 + sm_links: *id027 +- block_parents: *id006 + sm_links: *id027 +- block_parents: *id007 + sm_links: *id027 +- block_parents: *id002 + sm_links: &id028 + - [0, 1] + - [0, 2] + - [1, 4] + - [1, 5] +- block_parents: *id003 + sm_links: *id028 +- block_parents: *id005 + sm_links: *id028 +- block_parents: *id006 + sm_links: *id028 +- block_parents: *id007 + sm_links: *id028 +- block_parents: *id002 + sm_links: &id029 + - [0, 1] + - [0, 2] + - [1, 4] + - [2, 5] +- block_parents: *id003 + sm_links: *id029 +- block_parents: *id005 + sm_links: *id029 +- block_parents: *id006 + sm_links: *id029 +- block_parents: *id007 + sm_links: *id029 +- block_parents: *id002 + sm_links: &id030 + - [0, 1] + - [0, 2] + - [1, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id030 +- block_parents: *id005 + sm_links: *id030 +- block_parents: *id006 + sm_links: *id030 +- block_parents: *id007 + sm_links: *id030 +- block_parents: *id002 + sm_links: &id031 + - [0, 1] + - [0, 2] + - [2, 4] + - [2, 5] +- block_parents: *id003 + sm_links: *id031 +- block_parents: *id005 + sm_links: *id031 +- block_parents: *id006 + sm_links: *id031 +- block_parents: *id007 + sm_links: *id031 +- block_parents: *id002 + sm_links: &id032 + - [0, 1] + - [0, 2] + - [2, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id032 +- block_parents: *id005 + sm_links: *id032 +- block_parents: *id006 + sm_links: *id032 +- block_parents: *id007 + sm_links: *id032 +- block_parents: *id002 + sm_links: &id033 + - [0, 1] + - [0, 3] + - [0, 4] + - [0, 5] +- block_parents: *id003 + sm_links: *id033 +- block_parents: *id005 + sm_links: *id033 +- block_parents: *id006 + sm_links: *id033 +- block_parents: *id007 + sm_links: *id033 +- block_parents: *id002 + sm_links: &id034 + - [0, 2] + - [0, 3] + - [0, 4] + - [0, 5] +- block_parents: *id003 + sm_links: *id034 +- block_parents: *id005 + sm_links: *id034 +- block_parents: *id006 + sm_links: *id034 +- block_parents: *id007 + sm_links: *id034 +- block_parents: *id002 + sm_links: &id035 + - [0, 1] + - [0, 3] + - [0, 4] + - [1, 5] +- block_parents: *id003 + sm_links: *id035 +- block_parents: *id005 + sm_links: *id035 +- block_parents: *id006 + sm_links: *id035 +- block_parents: *id007 + sm_links: *id035 +- block_parents: *id002 + sm_links: &id036 + - [0, 1] + - [0, 3] + - [0, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id036 +- block_parents: *id005 + sm_links: *id036 +- block_parents: *id006 + sm_links: *id036 +- block_parents: *id007 + sm_links: *id036 +- block_parents: *id002 + sm_links: &id037 + - [0, 1] + - [0, 3] + - [0, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id037 +- block_parents: *id005 + sm_links: *id037 +- block_parents: *id006 + sm_links: *id037 +- block_parents: *id007 + sm_links: *id037 +- block_parents: *id002 + sm_links: &id038 + - [0, 2] + - [0, 3] + - [0, 4] + - [2, 5] +- block_parents: *id003 + sm_links: *id038 +- block_parents: *id005 + sm_links: *id038 +- block_parents: *id006 + sm_links: *id038 +- block_parents: *id007 + sm_links: *id038 +- block_parents: *id002 + sm_links: &id039 + - [0, 2] + - [0, 3] + - [0, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id039 +- block_parents: *id005 + sm_links: *id039 +- block_parents: *id006 + sm_links: *id039 +- block_parents: *id007 + sm_links: *id039 +- block_parents: *id002 + sm_links: &id040 + - [0, 2] + - [0, 3] + - [0, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id040 +- block_parents: *id005 + sm_links: *id040 +- block_parents: *id006 + sm_links: *id040 +- block_parents: *id007 + sm_links: *id040 +- block_parents: *id002 + sm_links: &id041 + - [0, 1] + - [0, 3] + - [1, 4] + - [1, 5] +- block_parents: *id003 + sm_links: *id041 +- block_parents: *id005 + sm_links: *id041 +- block_parents: *id006 + sm_links: *id041 +- block_parents: *id007 + sm_links: *id041 +- block_parents: *id002 + sm_links: &id042 + - [0, 1] + - [0, 3] + - [1, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id042 +- block_parents: *id005 + sm_links: *id042 +- block_parents: *id006 + sm_links: *id042 +- block_parents: *id007 + sm_links: *id042 +- block_parents: *id002 + sm_links: &id043 + - [0, 1] + - [0, 3] + - [1, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id043 +- block_parents: *id005 + sm_links: *id043 +- block_parents: *id006 + sm_links: *id043 +- block_parents: *id007 + sm_links: *id043 +- block_parents: *id002 + sm_links: &id044 + - [0, 1] + - [0, 3] + - [3, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id044 +- block_parents: *id005 + sm_links: *id044 +- block_parents: *id006 + sm_links: *id044 +- block_parents: *id007 + sm_links: *id044 +- block_parents: *id002 + sm_links: &id045 + - [0, 1] + - [0, 3] + - [3, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id045 +- block_parents: *id005 + sm_links: *id045 +- block_parents: *id006 + sm_links: *id045 +- block_parents: *id007 + sm_links: *id045 +- block_parents: *id002 + sm_links: &id046 + - [0, 2] + - [0, 3] + - [2, 4] + - [2, 5] +- block_parents: *id003 + sm_links: *id046 +- block_parents: *id005 + sm_links: *id046 +- block_parents: *id006 + sm_links: *id046 +- block_parents: *id007 + sm_links: *id046 +- block_parents: *id002 + sm_links: &id047 + - [0, 2] + - [0, 3] + - [2, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id047 +- block_parents: *id005 + sm_links: *id047 +- block_parents: *id006 + sm_links: *id047 +- block_parents: *id007 + sm_links: *id047 +- block_parents: *id002 + sm_links: &id048 + - [0, 2] + - [0, 3] + - [2, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id048 +- block_parents: *id005 + sm_links: *id048 +- block_parents: *id006 + sm_links: *id048 +- block_parents: *id007 + sm_links: *id048 +- block_parents: *id002 + sm_links: &id049 + - [0, 2] + - [0, 3] + - [3, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id049 +- block_parents: *id005 + sm_links: *id049 +- block_parents: *id006 + sm_links: *id049 +- block_parents: *id007 + sm_links: *id049 +- block_parents: *id002 + sm_links: &id050 + - [0, 2] + - [0, 3] + - [3, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id050 +- block_parents: *id005 + sm_links: *id050 +- block_parents: *id006 + sm_links: *id050 +- block_parents: *id007 + sm_links: *id050 +- block_parents: *id002 + sm_links: &id051 + - [0, 1] + - [1, 3] + - [1, 4] + - [1, 5] +- block_parents: *id003 + sm_links: *id051 +- block_parents: *id005 + sm_links: *id051 +- block_parents: *id006 + sm_links: *id051 +- block_parents: *id007 + sm_links: *id051 +- block_parents: *id002 + sm_links: &id052 + - [0, 1] + - [1, 3] + - [1, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id052 +- block_parents: *id005 + sm_links: *id052 +- block_parents: *id006 + sm_links: *id052 +- block_parents: *id007 + sm_links: *id052 +- block_parents: *id002 + sm_links: &id053 + - [0, 1] + - [1, 3] + - [1, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id053 +- block_parents: *id005 + sm_links: *id053 +- block_parents: *id006 + sm_links: *id053 +- block_parents: *id007 + sm_links: *id053 +- block_parents: *id002 + sm_links: &id054 + - [0, 1] + - [1, 3] + - [3, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id054 +- block_parents: *id005 + sm_links: *id054 +- block_parents: *id006 + sm_links: *id054 +- block_parents: *id007 + sm_links: *id054 +- block_parents: *id002 + sm_links: &id055 + - [0, 1] + - [1, 3] + - [3, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id055 +- block_parents: *id005 + sm_links: *id055 +- block_parents: *id006 + sm_links: *id055 +- block_parents: *id007 + sm_links: *id055 +- block_parents: *id002 + sm_links: &id056 + - [0, 2] + - [2, 3] + - [2, 4] + - [2, 5] +- block_parents: *id003 + sm_links: *id056 +- block_parents: *id005 + sm_links: *id056 +- block_parents: *id006 + sm_links: *id056 +- block_parents: *id007 + sm_links: *id056 +- block_parents: *id002 + sm_links: &id057 + - [0, 2] + - [2, 3] + - [2, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id057 +- block_parents: *id005 + sm_links: *id057 +- block_parents: *id006 + sm_links: *id057 +- block_parents: *id007 + sm_links: *id057 +- block_parents: *id002 + sm_links: &id058 + - [0, 2] + - [2, 3] + - [2, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id058 +- block_parents: *id005 + sm_links: *id058 +- block_parents: *id006 + sm_links: *id058 +- block_parents: *id007 + sm_links: *id058 +- block_parents: *id002 + sm_links: &id059 + - [0, 2] + - [2, 3] + - [3, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id059 +- block_parents: *id005 + sm_links: *id059 +- block_parents: *id006 + sm_links: *id059 +- block_parents: *id007 + sm_links: *id059 +- block_parents: *id002 + sm_links: &id060 + - [0, 2] + - [2, 3] + - [3, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id060 +- block_parents: *id005 + sm_links: *id060 +- block_parents: *id006 + sm_links: *id060 +- block_parents: *id007 + sm_links: *id060 +- block_parents: [0, 0, 1, 0, 0, 0] + sm_links: &id061 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: [0, 0, 0, 1, 0, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 0, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 0, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 0, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 1, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 1, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 1, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 1, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 1, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 1, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 2, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 2, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 2, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 2, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 2, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 2, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 3, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 3, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 3, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 3, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 3, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 3, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 0, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 0, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 0, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 0, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 0, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 0, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 1, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 1, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 1, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 1, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 1, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 1, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 2, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 2, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 2, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 2, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 2, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 2, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 3, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 3, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 3, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 3, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 3, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 3, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 0, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 0, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 0, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 0, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 0, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 0, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 1, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 1, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 1, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 1, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 1, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 1, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 2, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 2, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 2, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 2, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 2, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 2, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 3, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 3, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 3, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 3, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 3, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 3, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 0, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 0, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 0, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 0, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 0, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 0, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 1, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 1, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 1, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 1, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 1, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 1, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 2, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 2, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 2, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 2, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 2, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 2, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 3, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 3, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 3, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 3, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 3, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 3, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 0, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 0, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 0, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 0, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 0, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 0, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 1, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 1, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 1, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 1, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 1, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 1, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 2, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 2, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 2, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 2, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 2, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 2, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 3, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 3, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 3, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 3, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 3, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 3, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 2, 1, 0] + sm_links: &id062 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: [0, 0, 1, 2, 3, 1, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 0, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 0, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 1, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 1, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1, 0] + sm_links: &id063 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 5, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 5, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 5, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 4, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 4, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 4, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 4, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 4, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 5, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 5, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 5, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 5, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 5, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 diff --git a/tests/generators/fork_choice_generated/standard/block_tree_tree_2.yaml b/tests/generators/fork_choice_generated/standard/block_tree_tree_2.yaml new file mode 100644 index 0000000000..8a5deccc6d --- /dev/null +++ b/tests/generators/fork_choice_generated/standard/block_tree_tree_2.yaml @@ -0,0 +1,8424 @@ +- block_parents: &id002 [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1, 0] + sm_links: &id001 + - [0, 1] + - [0, 2] + - [0, 3] + - [0, 4] +- block_parents: &id003 [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 5, 4, 3, 2, 1, 0] + sm_links: *id001 +- block_parents: &id005 [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 5, 4, 3, 2, 1, 0] + sm_links: *id001 +- block_parents: &id006 [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 5, 4, 3, 2, 1, 0] + sm_links: *id001 +- block_parents: &id007 [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 4, 3, 2, 1, 0] + sm_links: *id001 +- block_parents: *id002 + sm_links: &id004 + - [0, 1] + - [0, 2] + - [0, 3] + - [0, 5] +- block_parents: *id003 + sm_links: *id004 +- block_parents: *id005 + sm_links: *id004 +- block_parents: *id006 + sm_links: *id004 +- block_parents: *id007 + sm_links: *id004 +- block_parents: *id002 + sm_links: &id008 + - [0, 1] + - [0, 2] + - [0, 3] + - [1, 4] +- block_parents: *id003 + sm_links: *id008 +- block_parents: *id005 + sm_links: *id008 +- block_parents: *id006 + sm_links: *id008 +- block_parents: *id007 + sm_links: *id008 +- block_parents: *id002 + sm_links: &id009 + - [0, 1] + - [0, 2] + - [0, 3] + - [2, 4] +- block_parents: *id003 + sm_links: *id009 +- block_parents: *id005 + sm_links: *id009 +- block_parents: *id006 + sm_links: *id009 +- block_parents: *id007 + sm_links: *id009 +- block_parents: *id002 + sm_links: &id010 + - [0, 1] + - [0, 2] + - [0, 3] + - [3, 4] +- block_parents: *id003 + sm_links: *id010 +- block_parents: *id005 + sm_links: *id010 +- block_parents: *id006 + sm_links: *id010 +- block_parents: *id007 + sm_links: *id010 +- block_parents: *id002 + sm_links: &id011 + - [0, 1] + - [0, 2] + - [0, 3] + - [1, 5] +- block_parents: *id003 + sm_links: *id011 +- block_parents: *id005 + sm_links: *id011 +- block_parents: *id006 + sm_links: *id011 +- block_parents: *id007 + sm_links: *id011 +- block_parents: *id002 + sm_links: &id012 + - [0, 1] + - [0, 2] + - [0, 3] + - [2, 5] +- block_parents: *id003 + sm_links: *id012 +- block_parents: *id005 + sm_links: *id012 +- block_parents: *id006 + sm_links: *id012 +- block_parents: *id007 + sm_links: *id012 +- block_parents: *id002 + sm_links: &id013 + - [0, 1] + - [0, 2] + - [0, 3] + - [3, 5] +- block_parents: *id003 + sm_links: *id013 +- block_parents: *id005 + sm_links: *id013 +- block_parents: *id006 + sm_links: *id013 +- block_parents: *id007 + sm_links: *id013 +- block_parents: *id002 + sm_links: &id014 + - [0, 1] + - [0, 2] + - [1, 3] + - [1, 4] +- block_parents: *id003 + sm_links: *id014 +- block_parents: *id005 + sm_links: *id014 +- block_parents: *id006 + sm_links: *id014 +- block_parents: *id007 + sm_links: *id014 +- block_parents: *id002 + sm_links: &id015 + - [0, 1] + - [0, 2] + - [1, 3] + - [2, 4] +- block_parents: *id003 + sm_links: *id015 +- block_parents: *id005 + sm_links: *id015 +- block_parents: *id006 + sm_links: *id015 +- block_parents: *id007 + sm_links: *id015 +- block_parents: *id002 + sm_links: &id016 + - [0, 1] + - [0, 2] + - [1, 3] + - [3, 4] +- block_parents: *id003 + sm_links: *id016 +- block_parents: *id005 + sm_links: *id016 +- block_parents: *id006 + sm_links: *id016 +- block_parents: *id007 + sm_links: *id016 +- block_parents: *id002 + sm_links: &id017 + - [0, 1] + - [0, 2] + - [1, 3] + - [1, 5] +- block_parents: *id003 + sm_links: *id017 +- block_parents: *id005 + sm_links: *id017 +- block_parents: *id006 + sm_links: *id017 +- block_parents: *id007 + sm_links: *id017 +- block_parents: *id002 + sm_links: &id018 + - [0, 1] + - [0, 2] + - [1, 3] + - [2, 5] +- block_parents: *id003 + sm_links: *id018 +- block_parents: *id005 + sm_links: *id018 +- block_parents: *id006 + sm_links: *id018 +- block_parents: *id007 + sm_links: *id018 +- block_parents: *id002 + sm_links: &id019 + - [0, 1] + - [0, 2] + - [1, 3] + - [3, 5] +- block_parents: *id003 + sm_links: *id019 +- block_parents: *id005 + sm_links: *id019 +- block_parents: *id006 + sm_links: *id019 +- block_parents: *id007 + sm_links: *id019 +- block_parents: *id002 + sm_links: &id020 + - [0, 1] + - [0, 2] + - [2, 3] + - [2, 4] +- block_parents: *id003 + sm_links: *id020 +- block_parents: *id005 + sm_links: *id020 +- block_parents: *id006 + sm_links: *id020 +- block_parents: *id007 + sm_links: *id020 +- block_parents: *id002 + sm_links: &id021 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: *id003 + sm_links: *id021 +- block_parents: *id005 + sm_links: *id021 +- block_parents: *id006 + sm_links: *id021 +- block_parents: *id007 + sm_links: *id021 +- block_parents: *id002 + sm_links: &id022 + - [0, 1] + - [0, 2] + - [2, 3] + - [2, 5] +- block_parents: *id003 + sm_links: *id022 +- block_parents: *id005 + sm_links: *id022 +- block_parents: *id006 + sm_links: *id022 +- block_parents: *id007 + sm_links: *id022 +- block_parents: *id002 + sm_links: &id023 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 5] +- block_parents: *id003 + sm_links: *id023 +- block_parents: *id005 + sm_links: *id023 +- block_parents: *id006 + sm_links: *id023 +- block_parents: *id007 + sm_links: *id023 +- block_parents: *id002 + sm_links: &id024 + - [0, 1] + - [0, 2] + - [0, 4] + - [0, 5] +- block_parents: *id003 + sm_links: *id024 +- block_parents: *id005 + sm_links: *id024 +- block_parents: *id006 + sm_links: *id024 +- block_parents: *id007 + sm_links: *id024 +- block_parents: *id002 + sm_links: &id025 + - [0, 1] + - [0, 2] + - [0, 4] + - [1, 5] +- block_parents: *id003 + sm_links: *id025 +- block_parents: *id005 + sm_links: *id025 +- block_parents: *id006 + sm_links: *id025 +- block_parents: *id007 + sm_links: *id025 +- block_parents: *id002 + sm_links: &id026 + - [0, 1] + - [0, 2] + - [0, 4] + - [2, 5] +- block_parents: *id003 + sm_links: *id026 +- block_parents: *id005 + sm_links: *id026 +- block_parents: *id006 + sm_links: *id026 +- block_parents: *id007 + sm_links: *id026 +- block_parents: *id002 + sm_links: &id027 + - [0, 1] + - [0, 2] + - [0, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id027 +- block_parents: *id005 + sm_links: *id027 +- block_parents: *id006 + sm_links: *id027 +- block_parents: *id007 + sm_links: *id027 +- block_parents: *id002 + sm_links: &id028 + - [0, 1] + - [0, 2] + - [1, 4] + - [1, 5] +- block_parents: *id003 + sm_links: *id028 +- block_parents: *id005 + sm_links: *id028 +- block_parents: *id006 + sm_links: *id028 +- block_parents: *id007 + sm_links: *id028 +- block_parents: *id002 + sm_links: &id029 + - [0, 1] + - [0, 2] + - [1, 4] + - [2, 5] +- block_parents: *id003 + sm_links: *id029 +- block_parents: *id005 + sm_links: *id029 +- block_parents: *id006 + sm_links: *id029 +- block_parents: *id007 + sm_links: *id029 +- block_parents: *id002 + sm_links: &id030 + - [0, 1] + - [0, 2] + - [1, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id030 +- block_parents: *id005 + sm_links: *id030 +- block_parents: *id006 + sm_links: *id030 +- block_parents: *id007 + sm_links: *id030 +- block_parents: *id002 + sm_links: &id031 + - [0, 1] + - [0, 2] + - [2, 4] + - [2, 5] +- block_parents: *id003 + sm_links: *id031 +- block_parents: *id005 + sm_links: *id031 +- block_parents: *id006 + sm_links: *id031 +- block_parents: *id007 + sm_links: *id031 +- block_parents: *id002 + sm_links: &id032 + - [0, 1] + - [0, 2] + - [2, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id032 +- block_parents: *id005 + sm_links: *id032 +- block_parents: *id006 + sm_links: *id032 +- block_parents: *id007 + sm_links: *id032 +- block_parents: *id002 + sm_links: &id033 + - [0, 1] + - [0, 3] + - [0, 4] + - [0, 5] +- block_parents: *id003 + sm_links: *id033 +- block_parents: *id005 + sm_links: *id033 +- block_parents: *id006 + sm_links: *id033 +- block_parents: *id007 + sm_links: *id033 +- block_parents: *id002 + sm_links: &id034 + - [0, 2] + - [0, 3] + - [0, 4] + - [0, 5] +- block_parents: *id003 + sm_links: *id034 +- block_parents: *id005 + sm_links: *id034 +- block_parents: *id006 + sm_links: *id034 +- block_parents: *id007 + sm_links: *id034 +- block_parents: *id002 + sm_links: &id035 + - [0, 1] + - [0, 3] + - [0, 4] + - [1, 5] +- block_parents: *id003 + sm_links: *id035 +- block_parents: *id005 + sm_links: *id035 +- block_parents: *id006 + sm_links: *id035 +- block_parents: *id007 + sm_links: *id035 +- block_parents: *id002 + sm_links: &id036 + - [0, 1] + - [0, 3] + - [0, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id036 +- block_parents: *id005 + sm_links: *id036 +- block_parents: *id006 + sm_links: *id036 +- block_parents: *id007 + sm_links: *id036 +- block_parents: *id002 + sm_links: &id037 + - [0, 1] + - [0, 3] + - [0, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id037 +- block_parents: *id005 + sm_links: *id037 +- block_parents: *id006 + sm_links: *id037 +- block_parents: *id007 + sm_links: *id037 +- block_parents: *id002 + sm_links: &id038 + - [0, 2] + - [0, 3] + - [0, 4] + - [2, 5] +- block_parents: *id003 + sm_links: *id038 +- block_parents: *id005 + sm_links: *id038 +- block_parents: *id006 + sm_links: *id038 +- block_parents: *id007 + sm_links: *id038 +- block_parents: *id002 + sm_links: &id039 + - [0, 2] + - [0, 3] + - [0, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id039 +- block_parents: *id005 + sm_links: *id039 +- block_parents: *id006 + sm_links: *id039 +- block_parents: *id007 + sm_links: *id039 +- block_parents: *id002 + sm_links: &id040 + - [0, 2] + - [0, 3] + - [0, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id040 +- block_parents: *id005 + sm_links: *id040 +- block_parents: *id006 + sm_links: *id040 +- block_parents: *id007 + sm_links: *id040 +- block_parents: *id002 + sm_links: &id041 + - [0, 1] + - [0, 3] + - [1, 4] + - [1, 5] +- block_parents: *id003 + sm_links: *id041 +- block_parents: *id005 + sm_links: *id041 +- block_parents: *id006 + sm_links: *id041 +- block_parents: *id007 + sm_links: *id041 +- block_parents: *id002 + sm_links: &id042 + - [0, 1] + - [0, 3] + - [1, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id042 +- block_parents: *id005 + sm_links: *id042 +- block_parents: *id006 + sm_links: *id042 +- block_parents: *id007 + sm_links: *id042 +- block_parents: *id002 + sm_links: &id043 + - [0, 1] + - [0, 3] + - [1, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id043 +- block_parents: *id005 + sm_links: *id043 +- block_parents: *id006 + sm_links: *id043 +- block_parents: *id007 + sm_links: *id043 +- block_parents: *id002 + sm_links: &id044 + - [0, 1] + - [0, 3] + - [3, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id044 +- block_parents: *id005 + sm_links: *id044 +- block_parents: *id006 + sm_links: *id044 +- block_parents: *id007 + sm_links: *id044 +- block_parents: *id002 + sm_links: &id045 + - [0, 1] + - [0, 3] + - [3, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id045 +- block_parents: *id005 + sm_links: *id045 +- block_parents: *id006 + sm_links: *id045 +- block_parents: *id007 + sm_links: *id045 +- block_parents: *id002 + sm_links: &id046 + - [0, 2] + - [0, 3] + - [2, 4] + - [2, 5] +- block_parents: *id003 + sm_links: *id046 +- block_parents: *id005 + sm_links: *id046 +- block_parents: *id006 + sm_links: *id046 +- block_parents: *id007 + sm_links: *id046 +- block_parents: *id002 + sm_links: &id047 + - [0, 2] + - [0, 3] + - [2, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id047 +- block_parents: *id005 + sm_links: *id047 +- block_parents: *id006 + sm_links: *id047 +- block_parents: *id007 + sm_links: *id047 +- block_parents: *id002 + sm_links: &id048 + - [0, 2] + - [0, 3] + - [2, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id048 +- block_parents: *id005 + sm_links: *id048 +- block_parents: *id006 + sm_links: *id048 +- block_parents: *id007 + sm_links: *id048 +- block_parents: *id002 + sm_links: &id049 + - [0, 2] + - [0, 3] + - [3, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id049 +- block_parents: *id005 + sm_links: *id049 +- block_parents: *id006 + sm_links: *id049 +- block_parents: *id007 + sm_links: *id049 +- block_parents: *id002 + sm_links: &id050 + - [0, 2] + - [0, 3] + - [3, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id050 +- block_parents: *id005 + sm_links: *id050 +- block_parents: *id006 + sm_links: *id050 +- block_parents: *id007 + sm_links: *id050 +- block_parents: *id002 + sm_links: &id051 + - [0, 1] + - [1, 3] + - [1, 4] + - [1, 5] +- block_parents: *id003 + sm_links: *id051 +- block_parents: *id005 + sm_links: *id051 +- block_parents: *id006 + sm_links: *id051 +- block_parents: *id007 + sm_links: *id051 +- block_parents: *id002 + sm_links: &id052 + - [0, 1] + - [1, 3] + - [1, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id052 +- block_parents: *id005 + sm_links: *id052 +- block_parents: *id006 + sm_links: *id052 +- block_parents: *id007 + sm_links: *id052 +- block_parents: *id002 + sm_links: &id053 + - [0, 1] + - [1, 3] + - [1, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id053 +- block_parents: *id005 + sm_links: *id053 +- block_parents: *id006 + sm_links: *id053 +- block_parents: *id007 + sm_links: *id053 +- block_parents: *id002 + sm_links: &id054 + - [0, 1] + - [1, 3] + - [3, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id054 +- block_parents: *id005 + sm_links: *id054 +- block_parents: *id006 + sm_links: *id054 +- block_parents: *id007 + sm_links: *id054 +- block_parents: *id002 + sm_links: &id055 + - [0, 1] + - [1, 3] + - [3, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id055 +- block_parents: *id005 + sm_links: *id055 +- block_parents: *id006 + sm_links: *id055 +- block_parents: *id007 + sm_links: *id055 +- block_parents: *id002 + sm_links: &id056 + - [0, 2] + - [2, 3] + - [2, 4] + - [2, 5] +- block_parents: *id003 + sm_links: *id056 +- block_parents: *id005 + sm_links: *id056 +- block_parents: *id006 + sm_links: *id056 +- block_parents: *id007 + sm_links: *id056 +- block_parents: *id002 + sm_links: &id057 + - [0, 2] + - [2, 3] + - [2, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id057 +- block_parents: *id005 + sm_links: *id057 +- block_parents: *id006 + sm_links: *id057 +- block_parents: *id007 + sm_links: *id057 +- block_parents: *id002 + sm_links: &id058 + - [0, 2] + - [2, 3] + - [2, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id058 +- block_parents: *id005 + sm_links: *id058 +- block_parents: *id006 + sm_links: *id058 +- block_parents: *id007 + sm_links: *id058 +- block_parents: *id002 + sm_links: &id059 + - [0, 2] + - [2, 3] + - [3, 4] + - [3, 5] +- block_parents: *id003 + sm_links: *id059 +- block_parents: *id005 + sm_links: *id059 +- block_parents: *id006 + sm_links: *id059 +- block_parents: *id007 + sm_links: *id059 +- block_parents: *id002 + sm_links: &id060 + - [0, 2] + - [2, 3] + - [3, 4] + - [4, 5] +- block_parents: *id003 + sm_links: *id060 +- block_parents: *id005 + sm_links: *id060 +- block_parents: *id006 + sm_links: *id060 +- block_parents: *id007 + sm_links: *id060 +- block_parents: [0, 0, 1, 0, 0, 0] + sm_links: &id061 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: [0, 0, 0, 1, 0, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 0, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 0, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 0, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 1, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 1, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 1, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 1, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 1, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 1, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 2, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 2, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 2, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 2, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 2, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 2, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 3, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 3, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 3, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 3, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 3, 0] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 3, 0] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 0, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 0, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 0, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 0, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 0, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 0, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 1, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 1, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 1, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 1, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 1, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 1, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 2, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 2, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 2, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 2, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 2, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 2, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 3, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 3, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 3, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 3, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 3, 1] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 3, 1] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 0, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 0, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 0, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 0, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 0, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 0, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 1, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 1, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 1, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 1, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 1, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 1, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 2, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 2, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 2, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 2, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 2, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 2, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 3, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 3, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 3, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 3, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 3, 2] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 3, 2] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 0, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 0, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 0, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 0, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 0, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 0, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 1, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 1, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 1, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 1, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 1, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 1, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 2, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 2, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 2, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 2, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 2, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 2, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 3, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 3, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 3, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 3, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 3, 3] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 3, 3] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 0, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 0, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 0, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 0, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 0, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 0, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 1, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 1, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 1, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 1, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 1, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 1, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 2, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 2, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 2, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 2, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 2, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 2, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 0, 3, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 0, 3, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 1, 3, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 3, 4] + sm_links: *id061 +- block_parents: [0, 0, 0, 2, 3, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 2, 3, 4] + sm_links: *id061 +- block_parents: [0, 0, 1, 1, 1, 0, 0] + sm_links: &id062 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: [0, 0, 1, 2, 1, 0, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 0, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 0, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 0, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 0, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 1, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 1, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 1, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 1, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 1, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 1, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 1, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 1, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 1, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 1, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 1, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 1, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 1, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 1, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 1, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 1, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 2, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 3, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 4, 0] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 0, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 0, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 0, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 0, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 0, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 0, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 0, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 0, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 0, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 0, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 0, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 0, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 0, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 0, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 0, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 0, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 1, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 1, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 1, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 1, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 1, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 1, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 1, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 1, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 1, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 1, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 1, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 1, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 1, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 1, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 1, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 1, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 2, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 3, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 4, 1] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 0, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 1, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 2, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 3, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 4, 2] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 0, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 1, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 2, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 3, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 4, 3] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 0, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 1, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 2, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 3, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 4, 4] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 0, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 1, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 2, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 3, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 0, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 0, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 0, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 0, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 0, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 1, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 1, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 1, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 1, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 1, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 1, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 2, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 2, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 2, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 2, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 2, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 2, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 0, 3, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 0, 3, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 1, 3, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 1, 3, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 0, 2, 3, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 4, 5] + sm_links: *id062 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1, 0] + sm_links: &id063 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 5, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 5, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 5, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 4, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 4, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 4, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 4, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 4, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 4, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 5, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 5, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 5, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 5, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 5, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 4, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 6, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 6, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 4, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 4, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 4, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 4, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 4, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 4, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 4, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 4, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 4, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 4, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 4, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 4, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 4, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 4, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 7, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 7, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 4, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 4, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 4, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 4, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 4, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 4, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 4, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 4, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 4, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 4, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 4, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 4, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 4, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 4, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 4, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 4, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 4, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 4, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 4, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 4, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 4, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 4, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 4, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 4, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 4, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 4, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 4, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 4, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 4, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 4, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 4, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 4, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 4, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 4, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 4, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 4, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 4, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 4, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 4, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 4, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 4, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 4, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 4, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 4, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 4, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 4, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 4, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 4, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 4, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 4, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 4, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 4, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 5, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 5, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 5, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 5, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 5, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 5, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 5, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 5, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 6, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 6, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 6, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 6, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 6, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 6, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 6, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 6, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 6, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 7, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 7, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 7, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 7, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 7, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 7, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 7, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 7, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 7, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 7, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 4, 8, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 4, 8, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 5, 8, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 5, 8, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 6, 8, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 6, 8, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 6, 8, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 7, 8, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 7, 8, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 3, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 5, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 5, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 5, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 5, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 6, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 6, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 6, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 6, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 6, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 6, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 6, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 6, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 7, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 7, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 7, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 7, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 7, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 7, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 7, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 7, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 7, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 7, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 7, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 7, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 7, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 8, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 8, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 8, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 8, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 8, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 8, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 8, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 8, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 8, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 8, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 8, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 8, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 8, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 9, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 9, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 9, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 9, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 9, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 9, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 9, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 9, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 9, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 9, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 9, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 9, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 9, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 9, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 9, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 3, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 6, 5, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 7, 5, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 7, 5, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 8, 5, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 5, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 5, 6, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 6, 6, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 7, 6, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 7, 6, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 7, 6, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 7, 6, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 8, 6, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 8, 6, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 8, 6, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 6, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 5, 7, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 5, 7, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 6, 7, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 6, 7, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 6, 7, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 6, 7, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 7, 7, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 7, 7, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 7, 7, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 8, 7, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 8, 7, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 8, 7, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 8, 7, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 7, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 5, 8, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 5, 8, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 6, 8, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 6, 8, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 6, 8, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 6, 8, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 7, 8, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 7, 8, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 7, 8, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 7, 8, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 7, 8, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 8, 8, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 8, 8, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 8, 8, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 8, 8, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 8, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 5, 9, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 5, 9, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 6, 9, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 6, 9, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 6, 9, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 6, 9, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 7, 9, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 7, 9, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 7, 9, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 7, 9, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 7, 9, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 8, 9, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 8, 9, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 8, 9, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 8, 9, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 9, 4, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 3, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 3, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 3, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 3, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 3, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 6, 4, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 7, 4, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 7, 4, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 8, 4, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 4, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 6, 5, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 6, 5, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 7, 5, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 7, 5, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 7, 5, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 7, 5, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 8, 5, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 8, 5, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 8, 5, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 8, 5, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 4, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 5, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 5, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 6, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 6, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 6, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 6, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 7, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 7, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 7, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 7, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 7, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 7, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 7, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 7, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 7, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 7, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 7, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 7, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 7, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 7, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 7, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 8, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 8, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 8, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 8, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 8, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 8, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 8, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 8, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 8, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 8, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 8, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 8, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 8, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 8, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 3, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 4, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 4, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 5, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 5, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 5, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 5, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 6, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 6, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 6, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 6, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 6, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 6, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 6, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 6, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 6, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 6, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 6, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 6, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 6, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 6, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 6, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 7, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 7, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 7, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 7, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 7, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 7, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 7, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 7, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 7, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 7, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 7, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 3, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 4, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 4, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 5, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 5, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 5, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 5, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 6, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 6, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 6, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 6, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 6, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 6, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 6, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 6, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 6, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 6, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 6, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 6, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 6, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 6, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 6, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 3, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 4, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 4, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 5, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 5, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 5, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 5, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 6, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 6, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 6, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 6, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 6, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 6, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 6, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 6, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 6, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 6, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 6, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 6, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 6, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 6, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 6, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 3, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 3, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 3, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 3, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 3, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 3, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 3, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 3, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 3, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 3, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 5, 4, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 6, 4, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 7, 4, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 7, 4, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 7, 4, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 7, 4, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 8, 4, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 8, 4, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 8, 4, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 4, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 4, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 5, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 5, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 6, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 6, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 6, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 6, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 7, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 7, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 7, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 7, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 7, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 7, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 7, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 7, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 7, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 7, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 7, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 7, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 7, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 7, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 7, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 8, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 8, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 8, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 8, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 8, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 8, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 8, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 8, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 8, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 8, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 8, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 8, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 8, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 8, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 3, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 4, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 5, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 5, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 5, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 5, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 7, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 7, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 7, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 7, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 7, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 7, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 7, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 7, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 7, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 7, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 7, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 8, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 8, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 8, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 8, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 8, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 8, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 8, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 8, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 8, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 8, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 8, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 6, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 3, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 3, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 3, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 4, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 4, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 4, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 4, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 5, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 5, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 5, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 5, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 5, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 5, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 5, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 5, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 5, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 5, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 5, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 5, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 5, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 5, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 5, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 6, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 6, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 6, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 6, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 6, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 6, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 6, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 6, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 6, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 6, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 6, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 7, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 7, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 7, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 7, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 7, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 7, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 7, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 7, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 7, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 7, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 7, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 7, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 7, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 7, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 7, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 7, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 3, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 3, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 3, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 4, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 4, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 4, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 4, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 5, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 5, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 5, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 5, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 5, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 5, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 5, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 5, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 5, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 5, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 5, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 5, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 5, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 5, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 5, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 6, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 6, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 6, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 6, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 6, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 6, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 6, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 6, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 6, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 6, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 6, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 3, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 3, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 3, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 4, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 4, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 4, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 4, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 5, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 5, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 5, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 5, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 5, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 5, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 5, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 5, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 5, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 5, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 5, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 5, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 5, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 5, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 5, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 6, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 6, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 6, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 6, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 6, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 6, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 6, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 6, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 6, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 6, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 6, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 6, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 3, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 3, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 3, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 3, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 3, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 3, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 3, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 3, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 3, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 3, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 3, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 3, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 3, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 3, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 5, 4, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 5, 4, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 6, 4, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 6, 4, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 6, 4, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 6, 4, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 7, 4, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 7, 4, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 7, 4, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 8, 4, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 8, 4, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 8, 4, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 8, 4, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 4, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 3, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 4, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 4, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 5, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 5, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 5, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 5, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 6, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 6, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 6, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 6, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 6, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 6, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 6, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 6, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 6, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 6, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 6, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 6, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 6, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 6, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 6, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 7, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 7, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 7, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 7, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 7, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 7, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 7, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 7, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 7, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 7, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 7, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 3, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 3, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 3, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 4, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 4, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 4, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 4, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 5, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 5, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 5, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 5, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 5, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 5, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 5, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 5, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 5, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 5, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 5, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 5, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 5, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 5, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 5, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 6, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 6, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 6, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 6, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 6, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 6, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 6, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 6, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 6, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 6, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 6, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 7, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 7, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 7, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 7, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 7, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 7, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 7, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 7, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 7, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 7, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 7, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 7, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 7, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 7, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 7, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 7, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 3, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 3, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 3, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 4, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 4, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 4, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 5, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 5, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 5, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 5, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 5, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 5, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 5, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 5, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 5, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 5, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 5, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 6, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 6, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 6, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 6, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 6, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 6, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 6, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 6, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 6, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 6, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 6, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 6, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 6, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 6, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 6, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 6, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 7, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 3, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 3, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 3, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 3, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 4, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 4, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 4, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 4, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 4, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 3, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 3, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 3, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 3, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 4, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 4, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 4, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 4, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 4, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 7, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 3, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 3, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 3, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 3, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 3, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 3, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 3, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 3, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 3, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 3, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 3, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 3, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 3, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 3, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 3, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 3, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 5, 4, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 5, 4, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 6, 4, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 6, 4, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 6, 4, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 6, 4, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 7, 4, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 7, 4, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 7, 4, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 7, 4, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 7, 4, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 8, 4, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 8, 4, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 8, 4, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 8, 4, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 4, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 3, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 4, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 4, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 5, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 5, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 5, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 5, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 6, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 6, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 6, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 6, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 6, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 6, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 6, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 6, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 6, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 6, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 6, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 6, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 6, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 6, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 6, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 3, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 3, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 3, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 4, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 4, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 4, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 4, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 5, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 5, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 5, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 5, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 5, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 5, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 5, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 5, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 5, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 5, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 5, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 5, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 5, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 5, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 5, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 6, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 6, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 6, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 6, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 6, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 6, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 6, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 6, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 6, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 6, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 6, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 3, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 3, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 3, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 3, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 4, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 4, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 4, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 4, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 4, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 3, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 3, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 3, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 3, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 4, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 4, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 4, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 4, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 4, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 3, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 3, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 3, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 3, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 4, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 4, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 4, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 4, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 4, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 3, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 4, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 4, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 5, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 5, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 5, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 5, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 5, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 5, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 6, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 6, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 6, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 6, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 6, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 6, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 3, 7, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 4, 7, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 5, 7, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 5, 7, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 3, 6, 7, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 4, 6, 7, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 5, 3, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 5, 3, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 6, 3, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 6, 3, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 6, 3, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 3, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 3, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 7, 3, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 3, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 7, 3, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 3, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 5, 8, 3, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 6, 8, 3, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 8, 3, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 7, 8, 3, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 3, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 5, 4, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 5, 4, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 6, 4, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 6, 4, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 6, 4, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 6, 4, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 7, 4, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 7, 4, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 7, 4, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 7, 4, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 7, 4, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 5, 8, 4, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 6, 8, 4, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 6, 8, 4, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 5, 7, 8, 4, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 3, 5, 6, 7, 8, 4, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 3, 5, 9, 4, 2, 1, 0] + sm_links: *id063 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 3, 5, 9, 4, 2, 1, 0] + sm_links: *id063 diff --git a/tests/generators/fork_choice_generated/standard/test_gen.yaml b/tests/generators/fork_choice_generated/standard/test_gen.yaml new file mode 100644 index 0000000000..d052871525 --- /dev/null +++ b/tests/generators/fork_choice_generated/standard/test_gen.yaml @@ -0,0 +1,38 @@ +block_tree_test: + test_type: block_tree + instances: standard/block_tree_tree.yaml # 1024 + seed: 123 + nr_variations: 2 + nr_mutations: 1 +block_weight_test: + test_type: block_tree + instances: standard/block_tree_other.yaml # 8 + seed: 123 + nr_variations: 64 + nr_mutations: 3 +shuffling_test: + test_type: block_tree + instances: standard/block_tree_other.yaml # 8 + seed: 6673 + nr_variations: 4 + nr_mutations: 63 +attester_slashing_test: + test_type: block_tree + instances: standard/block_tree_other.yaml # 8 + seed: 123 + nr_variations: 16 + nr_mutations: 7 + with_attester_slashings: true +invalid_message_test: + test_type: block_tree + instances: standard/block_tree_other.yaml # 8 + seed: 123 + nr_variations: 32 + nr_mutations: 3 + with_invalid_messages: true +block_cover_test: + test_type: block_cover + instances: standard/block_cover.yaml # 60 + seed: 456 + nr_variations: 5 + nr_mutations: 9 diff --git a/tests/generators/fork_choice_generated/test_gen.py b/tests/generators/fork_choice_generated/test_gen.py new file mode 100644 index 0000000000..1f925cecf5 --- /dev/null +++ b/tests/generators/fork_choice_generated/test_gen.py @@ -0,0 +1,99 @@ +from eth2spec.gen_helpers.gen_base import gen_runner +from eth2spec.gen_helpers.gen_base import settings +from ruamel.yaml import YAML + +from instance_generator import ( + forks, + presets, + _load_block_tree_instances, + _load_block_cover_instances, +) +from test_provider import GENERATOR_NAME, create_providers + + +def run_test_group(test_name, test_type, instances_path, + initial_seed, nr_variations, nr_mutations, + with_attester_slashings, with_invalid_messages, + debug=False, arg_parser=None): + if test_type == 'block_tree': + solutions = _load_block_tree_instances(instances_path) + if not with_attester_slashings and not with_invalid_messages: + test_kind = 'block_tree_test' + elif with_attester_slashings and not with_invalid_messages: + test_kind = 'attester_slashing_test' + elif not with_attester_slashings and with_invalid_messages: + test_kind = 'invalid_message_test' + else: + test_kind = 'attestet_slashing_and_invalid_message_test' + elif test_type == 'block_cover': + solutions = _load_block_cover_instances(instances_path) + test_kind = 'block_cover_test' + else: + raise ValueError(f'Unsupported test type: {test_type}') + + providers = create_providers(test_name, forks, presets, debug, initial_seed, + solutions, nr_variations, nr_mutations, test_kind) + gen_runner.run_generator(GENERATOR_NAME, providers, arg_parser) + + +def run_test_config(test_gen_config, debug=False, arg_parser=None): + for test_name, params in test_gen_config.items(): + print(test_name) + test_type = params['test_type'] + instances_path = params['instances'] + initial_seed = params['seed'] + nr_variations = params['nr_variations'] + nr_mutations = params['nr_mutations'] + with_attester_slashings = params.get('with_attester_slashings', False) + with_invalid_messages = params.get('with_invalid_messages', False) + + run_test_group(test_name, test_type, instances_path, + initial_seed, nr_variations, nr_mutations, + with_attester_slashings, with_invalid_messages, + debug=debug, arg_parser=arg_parser) + + +def main(): + arg_parser = gen_runner.create_arg_parser(GENERATOR_NAME) + + arg_parser.add_argument( + '--fc-gen-debug', + dest='fc_gen_debug', + action='store_true', + default=False, + required=False, + help='If set provides debug output and enable additional checks for generated chains', + ) + arg_parser.add_argument( + '--fc-gen-config', + dest='fc_gen_config', + type=str, + required=True, + help='Path to a file with test generator configurations' + ) + arg_parser.add_argument( + '--fc-gen-multi-processing', + dest='fc_gen_multi_processing', + action='store_true', + default=False, + required=False, + help='If set generates tests in the multi-processing mode', + ) + + args = arg_parser.parse_args() + + with open(args.fc_gen_config, 'r') as f: + yaml = YAML(typ='safe') + test_gen_config = yaml.load(f) + + if args.fc_gen_multi_processing: + settings.GENERATOR_MODE = settings.MODE_MULTIPROCESSING + print('generating tests in multi-processing mode') + else: + settings.GENERATOR_MODE = settings.MODE_SINGLE_PROCESS + print('generating tests in single process mode') + + run_test_config(test_gen_config, debug = args.fc_gen_debug, arg_parser=arg_parser) + +if __name__ == "__main__": + main() diff --git a/tests/generators/fork_choice_generated/test_provider.py b/tests/generators/fork_choice_generated/test_provider.py new file mode 100644 index 0000000000..006915cd63 --- /dev/null +++ b/tests/generators/fork_choice_generated/test_provider.py @@ -0,0 +1,286 @@ +from dataclasses import dataclass +from typing import Any, Iterable, Optional, Tuple +from eth2spec.gen_helpers.gen_base.gen_typing import TestCase, TestCasePart, TestProvider +from eth2spec.test.context import spec_test +from eth2spec.test.helpers.specs import spec_targets +from eth2spec.test.helpers.fork_choice import ( + on_tick_and_append_step, output_store_checks, + get_block_file_name, + get_attestation_file_name, + get_attester_slashing_file_name, +) +from eth2spec.test.helpers.typing import SpecForkName, PresetBaseName +from eth2spec.utils import bls +from scheduler import MessageScheduler +from instantiators.block_cover import yield_block_cover_test_case, yield_block_cover_test_data +from instantiators.block_tree import yield_block_tree_test_case, yield_block_tree_test_data +from instantiators.helpers import FCTestData, make_events, yield_fork_choice_test_events, filter_out_duplicate_messages +from instantiators.mutation_operators import MutationOps +import random + + +BLS_ACTIVE = False +GENERATOR_NAME = 'fork_choice_generated' + + +@dataclass +class FCTestDNA: + kind: str + solution: Any + variation_seed: int + mutation_seed: Optional[int] + + +@dataclass(init=False) +class PlainFCTestCase(TestCase): + test_dna: FCTestDNA + bls_active: bool + debug: bool + def __init__(self, test_dna, bls_active=False, debug=False, **kwds): + super().__init__(fork_name=kwds['fork_name'], preset_name=kwds['preset_name'], + runner_name=kwds['runner_name'], handler_name=kwds['handler_name'], + suite_name=kwds['suite_name'], case_name=kwds['case_name'], + case_fn=self.mutation_case_fn) + self.test_dna = test_dna + self.bls_active = bls_active + self.debug = debug + + def mutation_case_fn(self): + spec = spec_targets[self.preset_name][self.fork_name] + + mut_seed = self.test_dna.mutation_seed + test_data = list(self.call_instantiator(test_data_only=True))[0][2] + events = make_events(spec, test_data) + store = spec.get_forkchoice_store(test_data.anchor_state, test_data.anchor_block) + start_time = store.time + seconds_per_slot = spec.config.SECONDS_PER_SLOT + + if mut_seed is None: + return (spec_test(yield_fork_choice_test_events))( + spec, store, test_data, events, self.debug, generator_mode=True, bls_active=self.bls_active) + else: + test_vector = events_to_test_vector(events) + mops = MutationOps(start_time, seconds_per_slot) + mutated_vector, mutations = mops.rand_mutations(test_vector, 4, random.Random(mut_seed)) + + test_data.meta['mut_seed'] = mut_seed + test_data.meta['mutations'] = mutations + + mutated_events = test_vector_to_events(mutated_vector) + + # return (spec_test(yield_fork_choice_test_events))( + # spec, store, test_data, mutated_events, self.debug, generator_mode=True, bls_active=self.bls_active) + return (spec_test(yield_test_parts))( + spec, store, test_data, mutated_events, generator_mode=True, bls_active=self.bls_active) + + def plain_case_fn(self) -> Iterable[TestCasePart]: + yield from self.call_instantiator(test_data_only=False) + + def call_instantiator(self, test_data_only) -> Iterable[TestCasePart]: + phase, preset = self.fork_name, self.preset_name + bls_active, debug = self.bls_active, self.debug + solution, seed = self.test_dna.solution, self.test_dna.variation_seed + if self.test_dna.kind in ['block_tree_test', 'attester_slashing_test', 'invalid_message_test']: + with_attester_slashings = self.test_dna.kind == 'attester_slashing_test' + with_invalid_messages = self.test_dna.kind == 'invalid_message_test' + instantiator_fn = yield_block_tree_test_data if test_data_only else yield_block_tree_test_case + return instantiator_fn( + generator_mode=True, + phase=phase, preset=preset, + bls_active=bls_active, debug=debug, + seed=seed, sm_links=solution['sm_links'], block_parents=solution['block_parents'], + with_attester_slashings=with_attester_slashings, with_invalid_messages=with_invalid_messages) + elif self.test_dna.kind == 'block_cover_test': + instantiator_fn = yield_block_cover_test_data if test_data_only else yield_block_cover_test_case + return instantiator_fn( + generator_mode=True, + phase=phase, preset=preset, + bls_active=bls_active, debug=debug, + seed=seed, model_params=solution) + else: + raise ValueError(f'Unknown FC test kind {self.test_dna.kind}') + + +def events_to_test_vector(events) -> list[Any]: + test_vector = [] + current_time = None + for event in events: + event_kind, data, _ = event + if event_kind == 'tick': + current_time = data + else: + if event_kind == 'block': + event_id = data + elif event_kind == 'attestation': + event_id = data + elif event_kind == 'attester_slashing': + event_id = data + else: + assert False, event_kind + test_vector.append((current_time, (event_kind, event_id))) + return test_vector + + +def test_vector_to_events(test_vector): + events = [] + current_time = None + for time, (event_kind, data) in test_vector: + if time != current_time: + current_time = time + events.append(('tick', time, None)) + events.append((event_kind, data, None)) + return events + + +@filter_out_duplicate_messages +def yield_test_parts(spec, store, test_data: FCTestData, events): + record_recovery_messages = True + + for k,v in test_data.meta.items(): + yield k, 'meta', v + + yield 'anchor_state', test_data.anchor_state + yield 'anchor_block', test_data.anchor_block + + for message in test_data.blocks: + block = message.payload + yield get_block_file_name(block), block + + for message in test_data.atts: + attestation = message.payload + yield get_attestation_file_name(attestation), attestation + + for message in test_data.slashings: + attester_slashing = message.payload + yield get_attester_slashing_file_name(attester_slashing), attester_slashing + + test_steps = [] + scheduler = MessageScheduler(spec, store) + + # record first tick + on_tick_and_append_step(spec, store, store.time, test_steps) + + for (kind, data, _) in events: + if kind == 'tick': + time = data + if time > store.time: + applied_events = scheduler.process_tick(time) + if record_recovery_messages: + for (event_kind, event_data, recovery) in applied_events: + if event_kind == 'tick': + test_steps.append({'tick': int(event_data)}) + elif event_kind == 'block': + assert recovery + _block_id = get_block_file_name(event_data) + test_steps.append({'block': _block_id, 'valid': True}) + elif event_kind == 'attestation': + assert recovery + _attestation_id = get_attestation_file_name(event_data) + if _attestation_id not in test_data.atts: + yield _attestation_id, event_data + test_steps.append({'attestation': _attestation_id, 'valid': True}) + else: + assert False + else: + assert False + if time > store.time: + # inside a slot + on_tick_and_append_step(spec, store, time, test_steps) + else: + assert time == store.time + output_store_checks(spec, store, test_steps) + elif kind == 'block': + block = data + block_id = get_block_file_name(block) + valid, applied_events = scheduler.process_block(block) + if record_recovery_messages: + if valid: + for (event_kind, event_data, recovery) in applied_events: + if event_kind == 'block': + _block_id = get_block_file_name(event_data) + if recovery: + test_steps.append({'block': _block_id, 'valid': True}) + else: + test_steps.append({'block': _block_id, 'valid': True}) + elif event_kind == 'attestation': + _attestation_id = get_attestation_file_name(event_data) + if recovery: + if _attestation_id not in test_data.atts: + yield _attestation_id, event_data + test_steps.append({'attestation': _attestation_id, 'valid': True}) + else: + assert False + test_steps.append({'attestation': _attestation_id, 'valid': True}) + else: + assert False + else: + assert len(applied_events) == 0 + test_steps.append({'block': block_id, 'valid': valid}) + else: + assert False + test_steps.append({'block': block_id, 'valid': valid}) + block_root = block.message.hash_tree_root() + assert valid == (block_root in store.blocks) + + output_store_checks(spec, store, test_steps) + elif kind == 'attestation': + attestation = data + att_id = get_attestation_file_name(attestation) + valid = scheduler.process_attestation(attestation, is_from_block=False) + test_steps.append({'attestation': att_id, 'valid': valid}) + output_store_checks(spec, store, test_steps) + elif kind == 'attester_slashing': + attester_slashing = data + slashing_id = get_attester_slashing_file_name(attester_slashing) + valid = scheduler.process_slashing(attester_slashing) + test_steps.append({'attester_slashing': slashing_id, 'valid': valid}) + output_store_checks(spec, store, test_steps) + else: + raise ValueError(f'not implemented {kind}') + next_slot_time = store.genesis_time + (spec.get_current_slot(store) + 1) * spec.config.SECONDS_PER_SLOT + on_tick_and_append_step(spec, store, next_slot_time, test_steps) + output_store_checks(spec, store, test_steps, with_viable_for_head_weights=True) + + yield 'steps', test_steps + + +def create_providers(test_name: str, /, + forks: Iterable[SpecForkName], + presets: Iterable[PresetBaseName], + debug: bool, + initial_seed: int, + solutions, + number_of_variations: int, + number_of_mutations: int, + test_kind: str, + ) -> Iterable[TestProvider]: + def prepare_fn() -> None: + bls.use_milagro() + return + + seeds = [initial_seed] + if number_of_variations > 1: + rnd = random.Random(initial_seed) + seeds = [rnd.randint(1, 10000) for _ in range(number_of_variations)] + seeds[0] = initial_seed + + for fork_name in forks: + for preset_name in presets: + for i, solution in enumerate(solutions): + def make_cases_fn() -> Iterable[TestCase]: + for seed in seeds: + for j in range(1 + number_of_mutations): + test_dna = FCTestDNA(test_kind, solution, seed, None if j == 0 else seed + j - 1) + yield PlainFCTestCase( + test_dna=test_dna, + bls_active=BLS_ACTIVE, + debug=debug, + fork_name=fork_name, + preset_name=preset_name, + runner_name=GENERATOR_NAME, + handler_name=test_name, + suite_name='pyspec_tests', + case_name=test_name + '_' + str(i) + '_' + str(seed) + '_' + str(j), + ) + + yield TestProvider(prepare=prepare_fn, make_cases=make_cases_fn) diff --git a/tests/generators/fork_choice_generated/test_run.py b/tests/generators/fork_choice_generated/test_run.py new file mode 100644 index 0000000000..f5b09c1845 --- /dev/null +++ b/tests/generators/fork_choice_generated/test_run.py @@ -0,0 +1,173 @@ +import argparse +from collections import namedtuple +from glob import glob +from pathlib import Path +from pathos.multiprocessing import ProcessingPool as Pool +from ruamel.yaml import YAML +from snappy import uncompress +from tqdm import tqdm +from typing import Iterable + + +from eth2spec.gen_helpers.gen_base import settings +from eth2spec.test.helpers.specs import spec_targets +from eth2spec.utils import bls + + +bls.bls_active = False + + +def read_yaml(fp): + with open(fp) as f: + yaml = YAML(typ='safe') + return yaml.load(f.read()) + +def read_ssz_snappy(fp): + with open(fp, 'rb') as f: + res = uncompress(f.read()) + return res + + +def get_test_case(spec, td): + def get_prefix(p): + return p[p.rindex('/')+1:p.rindex('.')] + return (read_yaml(f'{td}/meta.yaml'), + spec.BeaconBlock.decode_bytes(read_ssz_snappy(f'{td}/anchor_block.ssz_snappy')), + spec.BeaconState.decode_bytes(read_ssz_snappy(f'{td}/anchor_state.ssz_snappy')), + {get_prefix(b): spec.SignedBeaconBlock.decode_bytes(read_ssz_snappy(b)) for b in glob(f'{td}/block_*.ssz_snappy')}, + {get_prefix(b): spec.Attestation.decode_bytes(read_ssz_snappy(b)) for b in glob(f'{td}/attestation_*.ssz_snappy')}, + {get_prefix(b): spec.AttesterSlashing.decode_bytes(read_ssz_snappy(b)) for b in glob(f'{td}/attester_slashing_*.ssz_snappy')}, + read_yaml(f'{td}/steps.yaml')) + + +TestInfo = namedtuple('TestInfo', ['preset', 'fork', 'test_dir',]) + + +def run_test(test_info): + preset, fork, test_dir = test_info + spec = spec_targets[preset][fork] + meta, anchor_block, anchor_state, blocks, atts, slashings, steps = get_test_case(spec, test_dir) + store = spec.get_forkchoice_store(anchor_state, anchor_block) + for step in steps: + if 'tick' in step: + time = step['tick'] + spec.on_tick(store, time) + elif 'block' in step: + block_id = step['block'] + valid = step.get('valid', True) + recovery = step.get('recovery', False) + signed_block = blocks[block_id] + if valid: + spec.on_block(store, signed_block) + for block_att in signed_block.message.body.attestations: + try: + spec.on_attestation(store, block_att, is_from_block=True) + except AssertionError: + pass + for block_att_slashing in signed_block.message.body.attester_slashings: + try: + spec.on_attester_slashing(store, block_att_slashing) + except AssertionError: + pass + else: + try: + spec.on_block(store, signed_block) + assert False + except AssertionError: + pass + elif 'attestation' in step: + att_id = step['attestation'] + valid = step.get('valid', True) + recovery = step.get('recovery', False) + attestation = atts[att_id] + if valid: + spec.on_attestation(store, attestation, is_from_block=False) + else: + try: + spec.on_attestation(store, attestation, is_from_block=False) + assert False + except AssertionError: + pass + elif 'attester_slashing' in step: + slashing_id = step['attester_slashing'] + valid = step.get('valid', True) + recovery = step.get('recovery', False) + assert valid + slashing = slashings[slashing_id] + spec.on_attester_slashing(store, slashing) + elif 'checks' in step: + checks = step['checks'] + for check, value in checks.items(): + if check == 'time': + expected_time = value + assert store.time == expected_time + elif check == 'head': + assert str(spec.get_head(store)) == value['root'] + elif check == 'proposer_boost_root': + assert str(store.proposer_boost_root) == str(value) + elif check == 'justified_checkpoint': + checkpoint = store.justified_checkpoint + assert checkpoint.epoch == value['epoch'] + assert str(checkpoint.root) == str(value['root']) + elif check == 'finalized_checkpoint': + checkpoint = store.finalized_checkpoint + assert checkpoint.epoch == value['epoch'] + assert str(checkpoint.root) == str(value['root']) + elif check == 'viable_for_head_roots_and_weights': + filtered_block_roots = spec.get_filtered_block_tree(store).keys() + leaves_viable_for_head = [root for root in filtered_block_roots + if not any(c for c in filtered_block_roots if store.blocks[c].parent_root == root)] + viable_for_head_roots_and_weights = { + str(viable_for_head_root): int(spec.get_weight(store, viable_for_head_root)) + for viable_for_head_root in leaves_viable_for_head + } + expected = { kv['root']: kv['weight'] for kv in value} + assert expected == viable_for_head_roots_and_weights + else: + assert False + else: + assert False + + +def gather_tests(tests_dir) -> Iterable[TestInfo]: + for preset in [p.name for p in Path(tests_dir).glob('*') if p.name in spec_targets]: + for fork in [f.name for f in (Path(tests_dir) / preset).glob('*') if f.name in spec_targets[preset]]: + print(f'{preset}/{fork}') + for test_dir in sorted([td for td in (Path(tests_dir) / preset / fork).glob('*/*/*/*')]): + yield TestInfo(preset, fork, test_dir) + + +def runt_tests_parallel(tests_dir, num_proc=settings.NUM_PROCESS): + def runner(test_info: TestInfo): + try: + run_test(test_info) + except Exception as e: + raise e + + tests = list(gather_tests(tests_dir)) + with Pool(processes=num_proc) as pool: + for _ in tqdm(pool.imap(runner, tests), total=len(tests)): + pass + + +def run_tests(tests_dir): + for test_info in gather_tests(tests_dir): + print(test_info.test_dir) + run_test(test_info) + + +def main(): + arg_parser = argparse.ArgumentParser() + arg_parser.add_argument( + "-i", + "--test-dir", + dest="test_dir", + required=True, + help="directory with generated tests" + ) + args = arg_parser.parse_args() + runt_tests_parallel(args.test_dir) + + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/tests/generators/fork_choice_generated/tiny/block_cover.yaml b/tests/generators/fork_choice_generated/tiny/block_cover.yaml new file mode 100644 index 0000000000..aa6d88f7d4 --- /dev/null +++ b/tests/generators/fork_choice_generated/tiny/block_cover.yaml @@ -0,0 +1,108 @@ +- block_epochs: [0] + current_epoch: 1 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: true} + previous_justifications: [false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1] + current_epoch: 1 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: true} + previous_justifications: [false, false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0] + current_epoch: 3 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: true} + previous_justifications: [false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [0, 1] + current_epoch: 3 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: true} + previous_justifications: [false, false] + store_justified_epoch: 0 + target_block: 0 +- block_epochs: [2] + current_epoch: 3 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 3 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2] + current_epoch: 5 + current_justifications: [false] + parents: [0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3] + current_epoch: 5 + current_justifications: [false, false] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: true, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 2 + target_block: 0 +- block_epochs: [2, 3, 3] + current_epoch: 4 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 3 + target_block: 1 +- block_epochs: [2, 3] + current_epoch: 4 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: true, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 3 + target_block: 0 +- block_epochs: [2, 3, 3] + current_epoch: 5 + current_justifications: [false, false, true] + parents: [0, 0, 0] + predicates: {block_is_leaf: true, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false, false] + store_justified_epoch: 3 + target_block: 1 +- block_epochs: [2, 3] + current_epoch: 5 + current_justifications: [false, true] + parents: [0, 0] + predicates: {block_is_leaf: false, block_vse_eq_store_je: false, block_vse_plus_two_ge_curr_e: false, + store_je_eq_zero: false} + previous_justifications: [false, false] + store_justified_epoch: 3 + target_block: 0 diff --git a/tests/generators/fork_choice_generated/tiny/block_tree_other.yaml b/tests/generators/fork_choice_generated/tiny/block_tree_other.yaml new file mode 100644 index 0000000000..edd147b557 --- /dev/null +++ b/tests/generators/fork_choice_generated/tiny/block_tree_other.yaml @@ -0,0 +1,10 @@ +- block_parents: [0, 0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0] + sm_links: &id001 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: [0, 0, 1, 2, 3, 4, 4, 5, 3, 2, 1, 0] + sm_links: *id001 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 5, 3, 2, 1, 0] + sm_links: *id001 diff --git a/tests/generators/fork_choice_generated/tiny/block_tree_tree.yaml b/tests/generators/fork_choice_generated/tiny/block_tree_tree.yaml new file mode 100644 index 0000000000..ca4f470ac8 --- /dev/null +++ b/tests/generators/fork_choice_generated/tiny/block_tree_tree.yaml @@ -0,0 +1,37 @@ +- block_parents: &id002 [0, 0, 1, 2, 3, 2, 1, 0] + sm_links: &id001 + - [0, 1] + - [0, 2] + - [0, 3] +- block_parents: &id003 [0, 0, 1, 2, 2, 3, 1, 0] + sm_links: *id001 +- block_parents: &id005 [0, 0, 1, 2, 3, 3, 1, 0] + sm_links: *id001 +- block_parents: *id002 + sm_links: &id004 + - [0, 1] + - [0, 2] + - [1, 3] +- block_parents: *id003 + sm_links: *id004 +- block_parents: *id005 + sm_links: *id004 +- block_parents: *id002 + sm_links: &id006 + - [0, 1] + - [0, 2] + - [2, 3] +- block_parents: *id003 + sm_links: *id006 +- block_parents: *id005 + sm_links: *id006 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1, 0] + sm_links: &id007 + - [0, 1] + - [0, 2] + - [2, 3] + - [3, 4] +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 6, 7, 5, 4, 3, 2, 1, 0] + sm_links: *id007 +- block_parents: [0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 5, 4, 3, 2, 1, 0] + sm_links: *id007 diff --git a/tests/generators/fork_choice_generated/tiny/test_gen.yaml b/tests/generators/fork_choice_generated/tiny/test_gen.yaml new file mode 100644 index 0000000000..7230ffc893 --- /dev/null +++ b/tests/generators/fork_choice_generated/tiny/test_gen.yaml @@ -0,0 +1,32 @@ +block_tree_test: + test_type: block_tree + instances: tiny/block_tree_tree.yaml # 12 + seed: 123 + nr_variations: 2 + nr_mutations: 1 +block_weight_test: + test_type: block_tree + instances: tiny/block_tree_other.yaml # 3 + seed: 123 + nr_variations: 5 + nr_mutations: 0 +attester_slashing_test: + test_type: block_tree + instances: tiny/block_tree_other.yaml # 3 + seed: 123 + nr_variations: 2 + nr_mutations: 1 + with_attester_slashings: true +invalid_message_test: + test_type: block_tree + instances: tiny/block_tree_other.yaml # 3 + seed: 123 + nr_variations: 2 + nr_mutations: 1 + with_invalid_messages: true +block_cover_test: + test_type: block_cover + instances: tiny/block_cover.yaml # 12 + seed: 456 + nr_variations: 2 + nr_mutations: 1