Repository: HigherOrderCO/Bend Branch: main Commit: d184863f03e7 Files: 1098 Total size: 2.8 MB Directory structure: gitextract_5jgx8w8i/ ├── .github/ │ ├── ISSUE_TEMPLATE/ │ │ ├── bug_report.yml │ │ ├── config.yml │ │ └── feature_request.md │ └── workflows/ │ └── checks.yml ├── .gitignore ├── .rustfmt.toml ├── CHANGELOG.md ├── CONTRIBUTING.md ├── Cargo.toml ├── FAQ.md ├── FEATURES.md ├── GUIDE.md ├── LICENSE-APACHE ├── README.md ├── cspell.json ├── docs/ │ ├── builtins.md │ ├── cli-arguments.md │ ├── compilation-and-readback.md │ ├── compiler-options.md │ ├── defining-data-types.md │ ├── dups-and-sups.md │ ├── ffi.md │ ├── imports.md │ ├── lazy-definitions.md │ ├── native-numbers.md │ ├── pattern-matching.md │ ├── syntax.md │ ├── type-checking.md │ ├── using-scopeless-lambdas.md │ └── writing-fusing-functions.md ├── examples/ │ ├── bitonic_sort.bend │ ├── bubble_sort.bend │ ├── callcc.bend │ ├── example_fun.bend │ ├── fib.bend │ ├── fusing_add.bend │ ├── fusing_not.bend │ ├── gen_tree.bend │ ├── hello_world.bend │ ├── insertion_sort.bend │ ├── list.bend │ ├── parallel_and.bend │ ├── parallel_sum.bend │ ├── queue.bend │ ├── quick_sort.bend │ └── radix_sort.bend ├── justfile ├── src/ │ ├── diagnostics.rs │ ├── fun/ │ │ ├── builtins.bend │ │ ├── builtins.rs │ │ ├── check/ │ │ │ ├── check_untyped.rs │ │ │ ├── mod.rs │ │ │ ├── set_entrypoint.rs │ │ │ ├── shared_names.rs │ │ │ ├── type_check.rs │ │ │ ├── unbound_refs.rs │ │ │ └── unbound_vars.rs │ │ ├── display.rs │ │ ├── load_book.rs │ │ ├── mod.rs │ │ ├── net_to_term.rs │ │ ├── parser.rs │ │ ├── term_to_net.rs │ │ └── transform/ │ │ ├── apply_args.rs │ │ ├── definition_merge.rs │ │ ├── definition_pruning.rs │ │ ├── desugar_bend.rs │ │ ├── desugar_fold.rs │ │ ├── desugar_match_defs.rs │ │ ├── desugar_open.rs │ │ ├── desugar_use.rs │ │ ├── desugar_with_blocks.rs │ │ ├── encode_adts.rs │ │ ├── encode_match_terms.rs │ │ ├── expand_generated.rs │ │ ├── expand_main.rs │ │ ├── fix_match_defs.rs │ │ ├── fix_match_terms.rs │ │ ├── float_combinators.rs │ │ ├── lift_local_defs.rs │ │ ├── linearize_matches.rs │ │ ├── linearize_vars.rs │ │ ├── mod.rs │ │ ├── resolve_refs.rs │ │ ├── resolve_type_ctrs.rs │ │ ├── resugar_list.rs │ │ ├── resugar_string.rs │ │ └── unique_names.rs │ ├── hvm/ │ │ ├── add_recursive_priority.rs │ │ ├── check_net_size.rs │ │ ├── eta_reduce.rs │ │ ├── inline.rs │ │ ├── mod.rs │ │ ├── mutual_recursion.message │ │ ├── mutual_recursion.rs │ │ └── prune.rs │ ├── imp/ │ │ ├── gen_map_get.rs │ │ ├── mod.rs │ │ ├── order_kwargs.rs │ │ ├── parser.rs │ │ └── to_fun.rs │ ├── imports/ │ │ ├── book.rs │ │ ├── loader.rs │ │ ├── mod.rs │ │ └── packages.rs │ ├── lib.rs │ ├── main.rs │ ├── net/ │ │ ├── hvm_to_net.rs │ │ └── mod.rs │ └── utils.rs └── tests/ ├── golden_tests/ │ ├── check_file/ │ │ ├── fail_type_bad_rec_fn_adt.bend │ │ ├── non_exaustive_limit.bend │ │ └── type_err_match_arm.bend │ ├── cli/ │ │ ├── compile_all.args │ │ ├── compile_all.bend │ │ ├── compile_inline.args │ │ ├── compile_inline.bend │ │ ├── compile_no_opts.args │ │ ├── compile_no_opts.bend │ │ ├── compile_pre_reduce.args │ │ ├── compile_pre_reduce.bend │ │ ├── compile_strict_loop.args │ │ ├── compile_strict_loop.bend │ │ ├── compile_wrong_opt.args │ │ ├── compile_wrong_opt.bend │ │ ├── custom_hvm_bin.args │ │ ├── custom_hvm_bin.bend │ │ ├── debug_list_map.args │ │ ├── debug_list_map.bend │ │ ├── debug_u60_to_nat.args │ │ ├── debug_u60_to_nat.bend │ │ ├── desugar_bool_scott.args │ │ ├── desugar_bool_scott.bend │ │ ├── desugar_float_combinators.args │ │ ├── desugar_float_combinators.bend │ │ ├── desugar_linearize_matches.args │ │ ├── desugar_linearize_matches.bend │ │ ├── desugar_linearize_matches_alt.args │ │ ├── desugar_linearize_matches_alt.bend │ │ ├── desugar_merge.args │ │ ├── desugar_merge.bend │ │ ├── desugar_pretty.args │ │ ├── desugar_pretty.bend │ │ ├── desugar_prune.args │ │ ├── desugar_prune.bend │ │ ├── gen_hvm_no_eta_by_default.args │ │ ├── gen_hvm_no_eta_by_default.bend │ │ ├── input_file_not_found.args │ │ ├── input_file_not_found.bend │ │ ├── net_size_too_large.args │ │ ├── net_size_too_large.bend │ │ ├── no_check_net_size.args │ │ ├── no_check_net_size.bend │ │ ├── run_add.args │ │ ├── run_add.bend │ │ ├── run_pretty.args │ │ ├── run_pretty.bend │ │ ├── tuple_readback.args │ │ ├── tuple_readback.bend │ │ ├── warn_and_err.args │ │ └── warn_and_err.bend │ ├── compile_entrypoint/ │ │ └── foo.bend │ ├── compile_file/ │ │ ├── 360_no_scope.bend │ │ ├── add_args.bend │ │ ├── addition.bend │ │ ├── addition_const.bend │ │ ├── ask_outside_do.bend │ │ ├── church_one.bend │ │ ├── church_zero.bend │ │ ├── complicated_dup.bend │ │ ├── crlf.bend │ │ ├── cyclic_global_lam.bend │ │ ├── def_pat_unscoped.bend │ │ ├── dup_apply.bend │ │ ├── dup_global_lam.bend │ │ ├── elif.bend │ │ ├── elif_fun.bend │ │ ├── elif_no_else.bend │ │ ├── erased_dup.bend │ │ ├── error_data_def_name.bend │ │ ├── error_messages.bend │ │ ├── f24_oper.bend │ │ ├── fst_snd.bend │ │ ├── global_lam.bend │ │ ├── i24_oper.bend │ │ ├── id.bend │ │ ├── infer_dup.bend │ │ ├── inlining.bend │ │ ├── just_a_name.bend │ │ ├── just_data.bend │ │ ├── just_paren.bend │ │ ├── just_rule_paren.bend │ │ ├── let_substitution.bend │ │ ├── let_tup.bend │ │ ├── lets.bend │ │ ├── long_name.bend │ │ ├── match.bend │ │ ├── mismatched_ask_statements.bend │ │ ├── missing_adt_eq.bend │ │ ├── missing_ctrs.bend │ │ ├── missing_pat.bend │ │ ├── names_starting_with_keywords.bend │ │ ├── nested_ctr_wrong_arity.bend │ │ ├── nested_let.bend │ │ ├── number_too_large.bend │ │ ├── nums.bend │ │ ├── op2.bend │ │ ├── redex_order.bend │ │ ├── redex_order_recursive.bend │ │ ├── ref_to_main.bend │ │ ├── ref_to_ref.bend │ │ ├── repeated_bind_rule.bend │ │ ├── simple_tup.bend │ │ ├── switch_all_patterns.bend │ │ ├── switch_in_switch_arg.bend │ │ ├── switch_incomplete.bend │ │ ├── switch_unscoped_lambda.bend │ │ ├── top_level_name_slashslash.bend │ │ ├── tup.bend │ │ ├── tup_add.bend │ │ ├── unbound_unscoped_var.bend │ │ ├── unbound_var.bend │ │ ├── unbound_var_scope.bend │ │ ├── unbound_with_tup_pattern.bend │ │ ├── underscore.bend │ │ ├── unexpected_top_char.bend │ │ ├── unscoped_dup_use.bend │ │ ├── unscoped_supercombinator.bend │ │ ├── unused_let.bend │ │ ├── unused_unscoped_bind.bend │ │ ├── variable_name_double_underscore.bend │ │ ├── vicious_circles.bend │ │ ├── warn_and_err.bend │ │ ├── with_clause_parse_err.bend │ │ ├── wrong_ctr_arity.bend │ │ ├── wrong_ctr_var_arity.bend │ │ ├── wrong_nums.bend │ │ └── wrong_unicode_escape.bend │ ├── compile_file_o_all/ │ │ ├── addition.bend │ │ ├── addition_var_fst.bend │ │ ├── adt_option_and.bend │ │ ├── adt_string.bend │ │ ├── and.bend │ │ ├── bad_parens_making_erased_let.bend │ │ ├── bool.bend │ │ ├── cyclic_dup.bend │ │ ├── double_main.bend │ │ ├── eta_chain.bend │ │ ├── ex0.bend │ │ ├── ex2.bend │ │ ├── example.bend │ │ ├── exp.bend │ │ ├── expr.bend │ │ ├── extracted_match_pred.bend │ │ ├── fst.bend │ │ ├── fst_fst.bend │ │ ├── hvm1_main.bend │ │ ├── inline_app.bend │ │ ├── inlining.bend │ │ ├── linearize_match.bend │ │ ├── list_merge_sort.bend │ │ ├── list_reverse.bend │ │ ├── match_adt_non_exhaustive.bend │ │ ├── match_dup_and_reconstruction.bend │ │ ├── match_mult_linearization.bend │ │ ├── match_num_explicit_bind.bend │ │ ├── match_tup.bend │ │ ├── merge_definitions.bend │ │ ├── non_exhaustive_and.bend │ │ ├── non_exhaustive_different_types.bend │ │ ├── non_exhaustive_pattern.bend │ │ ├── non_exhaustive_tree.bend │ │ ├── num_pattern_with_var.bend │ │ ├── recursive_combinator_inactive.bend │ │ ├── repeated_name_trucation.bend │ │ ├── scrutinee_reconstruction.bend │ │ ├── self_ref.bend │ │ ├── snd.bend │ │ ├── spacing.bend │ │ ├── spacing2.bend │ │ ├── str.bend │ │ ├── sum_predicates.bend │ │ ├── tagged_dup.bend │ │ ├── tagged_lam.bend │ │ ├── tagged_sup.bend │ │ ├── unapplied_eta.bend │ │ ├── unscoped_eta.bend │ │ ├── var_shadows_ref.bend │ │ └── weekday.bend │ ├── compile_file_o_no_all/ │ │ ├── bitonic_sort.bend │ │ ├── list_reverse.bend │ │ ├── redex_order.bend │ │ └── sum_tree.bend │ ├── compile_long/ │ │ ├── huge_tree.bend │ │ └── long_str_file.bend │ ├── desugar_file/ │ │ ├── ask_branch.bend │ │ ├── bind_syntax.bend │ │ ├── combinators.bend │ │ ├── deref_loop.bend │ │ ├── dup_linearization.bend │ │ ├── local_def_shadow.bend │ │ ├── main_aux.bend │ │ ├── mapper_syntax.bend │ │ ├── switch_with_use.bend │ │ ├── tree_syntax.bend │ │ ├── use_id.bend │ │ ├── use_shadow.bend │ │ └── used_once_names.bend │ ├── encode_pattern_match/ │ │ ├── adt_tup_era.bend │ │ ├── and3.bend │ │ ├── bool.bend │ │ ├── bool_tup.bend │ │ ├── box.bend │ │ ├── common.bend │ │ ├── concat.bend │ │ ├── concat_def.bend │ │ ├── def_tups.bend │ │ ├── definition_merge.bend │ │ ├── expr.bend │ │ ├── flatten_era_pat.bend │ │ ├── full_map.bend │ │ ├── is_some_some.bend │ │ ├── list_merge_sort.bend │ │ ├── list_str_encoding_undeclared_fn.bend │ │ ├── list_str_encoding_undeclared_map.bend │ │ ├── match_adt_unscoped_in_arm.bend │ │ ├── match_adt_unscoped_lambda.bend │ │ ├── match_adt_unscoped_var.bend │ │ ├── match_auto_linearization.bend │ │ ├── match_bind.bend │ │ ├── match_num_adt_tup_parser.bend │ │ ├── match_num_pred.bend │ │ ├── match_syntax.bend │ │ ├── merge_recursive.bend │ │ ├── no_patterns.bend │ │ ├── non_matching_fst_arg.bend │ │ ├── ntup_sum.bend │ │ ├── pattern_match_encoding.bend │ │ ├── switch_in_switch_arg.bend │ │ ├── var_only.bend │ │ └── weekday.bend │ ├── hangs/ │ │ ├── bad_dup_interaction.bend │ │ └── recursive_with_unscoped.bend │ ├── import_system/ │ │ ├── import_ctr_syntax.bend │ │ ├── import_main.bend │ │ ├── import_main2.bend │ │ ├── import_main3.bend │ │ ├── import_type.bend │ │ ├── import_types.bend │ │ ├── imports.bend │ │ ├── imports_alias.bend │ │ ├── imports_alias_shadow.bend │ │ ├── imports_conflict.bend │ │ ├── imports_file_and_dir.bend │ │ ├── imports_file_and_dir_conflict.bend │ │ ├── imports_shadow.bend │ │ ├── imports_shadow2.bend │ │ └── lib/ │ │ ├── MyOption.bend │ │ ├── a/ │ │ │ └── b.bend │ │ ├── a.bend │ │ ├── bool_xor.bend │ │ ├── ctr_type.bend │ │ ├── defs.bend │ │ ├── file_and_dir/ │ │ │ ├── w.bend │ │ │ └── y.bend │ │ ├── file_and_dir.bend │ │ ├── folder/ │ │ │ ├── import_entry3.bend │ │ │ └── myFun.bend │ │ ├── import_entry.bend │ │ ├── import_entry2.bend │ │ ├── myFun.bend │ │ ├── nums.bend │ │ └── types.bend │ ├── io/ │ │ ├── eof.txt │ │ ├── load.bend │ │ ├── load.txt │ │ ├── load_fail.bend │ │ ├── read_line_eof.bend │ │ ├── store.bend │ │ ├── store.txt │ │ ├── store_fail.bend │ │ └── utf8.bend │ ├── linear_readback/ │ │ └── church_mul.bend │ ├── mutual_recursion/ │ │ ├── a_b_c.bend │ │ ├── len.bend │ │ ├── merged.bend │ │ ├── multiple.bend │ │ └── odd_even.bend │ ├── parse_file/ │ │ ├── bad_floating.bend │ │ ├── bend_missing_else.bend │ │ ├── era.bend │ │ ├── fold_missing_case.bend │ │ ├── fun_def.bend │ │ ├── fun_def_name.bend │ │ ├── if_missing_else.bend │ │ ├── imp_map.bend │ │ ├── imp_program.bend │ │ ├── match_missing_case.bend │ │ ├── multi_line_comment.bend │ │ ├── redefinition_builtin.bend │ │ ├── redefinition_ctr_with_fun.bend │ │ ├── redefinition_fun_imp.bend │ │ ├── redefinition_imp_fun.bend │ │ ├── redefinition_type_with_object.bend │ │ ├── redefinition_with_def_between.bend │ │ ├── redefinition_with_object_between.bend │ │ ├── redefinition_with_type_between.bend │ │ ├── repeated_adt_name.bend │ │ ├── repeated_datatype_name.bend │ │ ├── scape_chars.bend │ │ ├── strange_pattern.bend │ │ ├── tab.bend │ │ ├── tup_with_signed.bend │ │ ├── tuple_assign.bend │ │ ├── tuple_commas.bend │ │ └── tuple_need_parens.bend │ ├── prelude/ │ │ ├── applies_function_to_map.bend │ │ ├── get_values_from_map.bend │ │ ├── lists_to_map.bend │ │ ├── map_checked_test.bend │ │ ├── map_contains_test.bend │ │ └── set_node_when_empty.bend │ ├── readback_hvm/ │ │ ├── addition.bend │ │ ├── bad_net.bend │ │ ├── bad_net1.bend │ │ ├── bad_net3.bend │ │ ├── complicated_dup.bend │ │ ├── fst_snd.bend │ │ ├── id.bend │ │ ├── invalid_op2_op2.bend │ │ ├── match.bend │ │ ├── nested_let.bend │ │ ├── nested_tup.bend │ │ ├── number.bend │ │ ├── simple_tup.bend │ │ └── tup_add.bend │ ├── run_entrypoint/ │ │ └── foo.bend │ ├── run_file/ │ │ ├── 360_no_scope.bend │ │ ├── addition.bend │ │ ├── adt_match.bend │ │ ├── adt_match_wrong_tag.bend │ │ ├── adt_option_and.bend │ │ ├── adt_wrong_tag.bend │ │ ├── and.bend │ │ ├── basic_num_ops.bend │ │ ├── bend_fold.bend │ │ ├── bitonic_sort.bend │ │ ├── bitonic_sort_lam.bend │ │ ├── box.bend │ │ ├── branch_statements_assignment.bend │ │ ├── callcc.bend │ │ ├── chars.bend │ │ ├── chars_forall.bend │ │ ├── chars_lambda.bend │ │ ├── checked_scott_encoding.bend │ │ ├── comprehension.bend │ │ ├── def_bool_num.bend │ │ ├── def_num_bool.bend │ │ ├── def_tups.bend │ │ ├── do_block_mixed.bend │ │ ├── dup_global_lam.bend │ │ ├── empty.bend │ │ ├── encode_decode_utf8.bend │ │ ├── erased_side_effect.bend │ │ ├── escape_sequences.bend │ │ ├── eta.bend │ │ ├── example.bend │ │ ├── exp.bend │ │ ├── expand_main_combinator.bend │ │ ├── expand_main_list.bend │ │ ├── extracted_match_pred.bend │ │ ├── filter_bool_id.bend │ │ ├── floating_numbers.bend │ │ ├── fold_with_state.bend │ │ ├── guide_bend_7tree.bend │ │ ├── guide_bend_sequential.bend │ │ ├── guide_bend_sum_tree.bend │ │ ├── guide_bitonic_sort.bend │ │ ├── guide_circle_area.bend │ │ ├── guide_distance_4args.bend │ │ ├── guide_distance_obj.bend │ │ ├── guide_distance_tup.bend │ │ ├── guide_enumerate.bend │ │ ├── guide_if_age.bend │ │ ├── guide_is_even_num.bend │ │ ├── guide_is_even_str.bend │ │ ├── guide_list_ctrs.bend │ │ ├── guide_list_match.bend │ │ ├── guide_list_sugar.bend │ │ ├── guide_mul2_inline.bend │ │ ├── guide_mul2_rec.bend │ │ ├── guide_shader_dummy.bend │ │ ├── guide_sum.bend │ │ ├── hvm_def_cast.bend │ │ ├── hvm_def_two_defs.bend │ │ ├── id_underscore.bend │ │ ├── imp_empty_literals.bend │ │ ├── imp_use_statement.bend │ │ ├── kind_compiled_tree_sum.bend │ │ ├── lam_op2.bend │ │ ├── lam_op2_nested.bend │ │ ├── let_tup_readback.bend │ │ ├── linearize_match.bend │ │ ├── list_resugar.bend │ │ ├── list_reverse.bend │ │ ├── list_reverse_imp.bend │ │ ├── list_take.bend │ │ ├── list_to_tree.bend │ │ ├── mapper_syntax.bend │ │ ├── match.bend │ │ ├── match_builtins.bend │ │ ├── match_mult_linearization.bend │ │ ├── match_num_adt_tup_parser.bend │ │ ├── match_num_explicit_bind.bend │ │ ├── match_num_num_to_char.bend │ │ ├── match_num_succ_complex.bend │ │ ├── match_str.bend │ │ ├── match_sup.bend │ │ ├── match_vars.bend │ │ ├── math.bend │ │ ├── merge_sort.bend │ │ ├── mixed_syntax.bend │ │ ├── names_hyphen.bend │ │ ├── names_hyphen_toplevel.bend │ │ ├── nat_add.bend │ │ ├── nat_add_num.bend │ │ ├── nested_list_and_string.bend │ │ ├── nested_map_get.bend │ │ ├── nested_map_set.bend │ │ ├── nested_str.bend │ │ ├── num_cast.bend │ │ ├── num_match_missing_var.bend │ │ ├── num_pred.bend │ │ ├── open.bend │ │ ├── open_object.bend │ │ ├── open_too_many_ctrs.bend │ │ ├── open_undefined_type.bend │ │ ├── ops.bend │ │ ├── override_list_ctr.bend │ │ ├── override_str_ctr.bend │ │ ├── pred.bend │ │ ├── queue.bend │ │ ├── radix_sort_ctr.bend │ │ ├── readback_hvm1_main.bend │ │ ├── readback_list_other_ctr.bend │ │ ├── readback_num_ops.bend │ │ ├── recursive_bind.bend │ │ ├── recursive_combinator.bend │ │ ├── recursive_combinator_nested.bend │ │ ├── recursive_match_native.bend │ │ ├── ref_resolution.bend │ │ ├── repeated_name_truncation.bend │ │ ├── scopeless_discard.bend │ │ ├── str_concat.bend │ │ ├── str_inc.bend │ │ ├── str_inc_eta.bend │ │ ├── str_len.bend │ │ ├── strict_monad_fn.bend │ │ ├── sum_tree.bend │ │ ├── sup_app.bend │ │ ├── sup_reconstruction.bend │ │ ├── superposed_is_even.bend │ │ ├── tagged_lam.bend │ │ ├── tree_to_list.bend │ │ ├── tup_list_strings.bend │ │ ├── tup_reconstruction.bend │ │ ├── tuple_eta.bend │ │ ├── tuple_rots.bend │ │ ├── unaplied_str.bend │ │ ├── unbound_wrap.bend │ │ ├── unscoped_never_used.bend │ │ ├── unused_dup_var.bend │ │ ├── unused_main_var.bend │ │ ├── world.bend │ │ └── wrong_string.bend │ ├── run_lazy/ │ │ ├── addition.bend │ │ ├── adt_match.bend │ │ ├── adt_match_wrong_tag.bend │ │ ├── adt_option_and.bend │ │ ├── adt_wrong_tag.bend │ │ ├── and.bend │ │ ├── bitonic_sort.bend │ │ ├── bitonic_sort_lam.bend │ │ ├── box.bend │ │ ├── box2.bend │ │ ├── callcc.bend │ │ ├── chars.bend │ │ ├── def_tups.bend │ │ ├── dup_global_lam.bend │ │ ├── eta.bend │ │ ├── example.bend │ │ ├── exp.bend │ │ ├── extracted_match_pred.bend │ │ ├── field_vectorization.bend │ │ ├── lam_op2.bend │ │ ├── lam_op2_nested.bend │ │ ├── let_tup_readback.bend │ │ ├── linearize_match.bend │ │ ├── list_resugar.bend │ │ ├── list_reverse.bend │ │ ├── list_take.bend │ │ ├── list_to_tree.bend │ │ ├── match.bend │ │ ├── match_builtins.bend │ │ ├── match_mult_linearization.bend │ │ ├── match_num_explicit_bind.bend │ │ ├── merge_sort.bend │ │ ├── nested_list_and_string.bend │ │ ├── nested_str.bend │ │ ├── num_pred.bend │ │ ├── queue.bend │ │ ├── radix_sort_ctr.bend │ │ ├── recursive_match_native.bend │ │ ├── scopeless_discard.bend │ │ ├── str_concat.bend │ │ ├── str_inc.bend │ │ ├── str_inc_eta.bend │ │ ├── str_len.bend │ │ ├── sum_tree.bend │ │ ├── sup_app.bend │ │ ├── sup_reconstruction.bend │ │ ├── superposed_is_even.bend │ │ ├── tagged_lam.bend │ │ ├── tup_reconstruction.bend │ │ ├── tuple_rots.bend │ │ ├── unaplied_str.bend │ │ ├── unused_dup_var.bend │ │ ├── world.bend │ │ └── wrong_string.bend │ ├── scott_triggers_unused/ │ │ └── test.bend │ └── simplify_matches/ │ ├── adt_tup_era.bend │ ├── already_flat.bend │ ├── bits_dec.bend │ ├── complex_with_case.bend │ ├── double_unwrap_box.bend │ ├── double_unwrap_maybe.bend │ ├── flatten_with_terminal.bend │ ├── irrefutable_case.bend │ ├── linearize_match_all.bend │ ├── match_str.bend │ ├── nested.bend │ ├── nested2.bend │ ├── nested_0ary.bend │ ├── redundant_with_era.bend │ └── wrong_fn_arity.bend ├── golden_tests.rs └── snapshots/ ├── check_file__fail_type_bad_rec_fn_adt.bend.snap ├── check_file__non_exaustive_limit.bend.snap ├── check_file__type_err_match_arm.bend.snap ├── cli__compile_all.bend.snap ├── cli__compile_inline.bend.snap ├── cli__compile_no_opts.bend.snap ├── cli__compile_pre_reduce.bend.snap ├── cli__compile_strict_loop.bend.snap ├── cli__compile_wrong_opt.bend.snap ├── cli__custom_hvm_bin.bend.snap ├── cli__debug_list_map.bend.snap ├── cli__debug_u60_to_nat.bend.snap ├── cli__desugar_bool_scott.bend.snap ├── cli__desugar_float_combinators.bend.snap ├── cli__desugar_linearize_matches.bend.snap ├── cli__desugar_linearize_matches_alt.bend.snap ├── cli__desugar_merge.bend.snap ├── cli__desugar_pretty.bend.snap ├── cli__desugar_prune.bend.snap ├── cli__gen_hvm_no_eta_by_default.bend.snap ├── cli__input_file_not_found.bend.snap ├── cli__net_size_too_large.bend.snap ├── cli__no_check_net_size.bend.snap ├── cli__run_add.bend.snap ├── cli__run_pretty.bend.snap ├── cli__tuple_readback.bend.snap ├── cli__warn_and_err.bend.snap ├── compile_entrypoint__foo.bend.snap ├── compile_file__360_no_scope.bend.snap ├── compile_file__add_args.bend.snap ├── compile_file__addition.bend.snap ├── compile_file__addition_const.bend.snap ├── compile_file__ask_outside_do.bend.snap ├── compile_file__church_one.bend.snap ├── compile_file__church_zero.bend.snap ├── compile_file__complicated_dup.bend.snap ├── compile_file__crlf.bend.snap ├── compile_file__cyclic_global_lam.bend.snap ├── compile_file__def_pat_unscoped.bend.snap ├── compile_file__dup_apply.bend.snap ├── compile_file__dup_global_lam.bend.snap ├── compile_file__elif.bend.snap ├── compile_file__elif_fun.bend.snap ├── compile_file__elif_no_else.bend.snap ├── compile_file__erased_dup.bend.snap ├── compile_file__error_data_def_name.bend.snap ├── compile_file__error_messages.bend.snap ├── compile_file__f24_oper.bend.snap ├── compile_file__fst_snd.bend.snap ├── compile_file__global_lam.bend.snap ├── compile_file__i24_oper.bend.snap ├── compile_file__id.bend.snap ├── compile_file__infer_dup.bend.snap ├── compile_file__inlining.bend.snap ├── compile_file__just_a_name.bend.snap ├── compile_file__just_data.bend.snap ├── compile_file__just_paren.bend.snap ├── compile_file__just_rule_paren.bend.snap ├── compile_file__let_substitution.bend.snap ├── compile_file__let_tup.bend.snap ├── compile_file__lets.bend.snap ├── compile_file__long_name.bend.snap ├── compile_file__match.bend.snap ├── compile_file__mismatched_ask_statements.bend.snap ├── compile_file__missing_adt_eq.bend.snap ├── compile_file__missing_ctrs.bend.snap ├── compile_file__missing_pat.bend.snap ├── compile_file__names_starting_with_keywords.bend.snap ├── compile_file__nested_ctr_wrong_arity.bend.snap ├── compile_file__nested_let.bend.snap ├── compile_file__number_too_large.bend.snap ├── compile_file__nums.bend.snap ├── compile_file__op2.bend.snap ├── compile_file__redex_order.bend.snap ├── compile_file__redex_order_recursive.bend.snap ├── compile_file__ref_to_main.bend.snap ├── compile_file__ref_to_ref.bend.snap ├── compile_file__repeated_bind_rule.bend.snap ├── compile_file__simple_tup.bend.snap ├── compile_file__switch_all_patterns.bend.snap ├── compile_file__switch_in_switch_arg.bend.snap ├── compile_file__switch_incomplete.bend.snap ├── compile_file__switch_unscoped_lambda.bend.snap ├── compile_file__top_level_name_slashslash.bend.snap ├── compile_file__tup.bend.snap ├── compile_file__tup_add.bend.snap ├── compile_file__unbound_unscoped_var.bend.snap ├── compile_file__unbound_var.bend.snap ├── compile_file__unbound_var_scope.bend.snap ├── compile_file__unbound_with_tup_pattern.bend.snap ├── compile_file__underscore.bend.snap ├── compile_file__unexpected_top_char.bend.snap ├── compile_file__unscoped_dup_use.bend.snap ├── compile_file__unscoped_supercombinator.bend.snap ├── compile_file__unused_let.bend.snap ├── compile_file__unused_unscoped_bind.bend.snap ├── compile_file__variable_name_double_underscore.bend.snap ├── compile_file__vicious_circles.bend.snap ├── compile_file__warn_and_err.bend.snap ├── compile_file__with_clause_parse_err.bend.snap ├── compile_file__wrong_ctr_arity.bend.snap ├── compile_file__wrong_ctr_var_arity.bend.snap ├── compile_file__wrong_nums.bend.snap ├── compile_file__wrong_unicode_escape.bend.snap ├── compile_file_o_all__addition.bend.snap ├── compile_file_o_all__addition_var_fst.bend.snap ├── compile_file_o_all__adt_option_and.bend.snap ├── compile_file_o_all__adt_string.bend.snap ├── compile_file_o_all__and.bend.snap ├── compile_file_o_all__bad_parens_making_erased_let.bend.snap ├── compile_file_o_all__bool.bend.snap ├── compile_file_o_all__cyclic_dup.bend.snap ├── compile_file_o_all__double_main.bend.snap ├── compile_file_o_all__eta_chain.bend.snap ├── compile_file_o_all__ex0.bend.snap ├── compile_file_o_all__ex2.bend.snap ├── compile_file_o_all__example.bend.snap ├── compile_file_o_all__exp.bend.snap ├── compile_file_o_all__expr.bend.snap ├── compile_file_o_all__extracted_match_pred.bend.snap ├── compile_file_o_all__fst.bend.snap ├── compile_file_o_all__fst_fst.bend.snap ├── compile_file_o_all__hvm1_main.bend.snap ├── compile_file_o_all__inline_app.bend.snap ├── compile_file_o_all__inlining.bend.snap ├── compile_file_o_all__linearize_match.bend.snap ├── compile_file_o_all__list_merge_sort.bend.snap ├── compile_file_o_all__list_reverse.bend.snap ├── compile_file_o_all__match_adt_non_exhaustive.bend.snap ├── compile_file_o_all__match_dup_and_reconstruction.bend.snap ├── compile_file_o_all__match_mult_linearization.bend.snap ├── compile_file_o_all__match_num_explicit_bind.bend.snap ├── compile_file_o_all__match_tup.bend.snap ├── compile_file_o_all__merge_definitions.bend.snap ├── compile_file_o_all__non_exhaustive_and.bend.snap ├── compile_file_o_all__non_exhaustive_different_types.bend.snap ├── compile_file_o_all__non_exhaustive_pattern.bend.snap ├── compile_file_o_all__non_exhaustive_tree.bend.snap ├── compile_file_o_all__num_pattern_with_var.bend.snap ├── compile_file_o_all__recursive_combinator_inactive.bend.snap ├── compile_file_o_all__repeated_name_trucation.bend.snap ├── compile_file_o_all__scrutinee_reconstruction.bend.snap ├── compile_file_o_all__self_ref.bend.snap ├── compile_file_o_all__snd.bend.snap ├── compile_file_o_all__spacing.bend.snap ├── compile_file_o_all__spacing2.bend.snap ├── compile_file_o_all__str.bend.snap ├── compile_file_o_all__sum_predicates.bend.snap ├── compile_file_o_all__tagged_dup.bend.snap ├── compile_file_o_all__tagged_lam.bend.snap ├── compile_file_o_all__tagged_sup.bend.snap ├── compile_file_o_all__unapplied_eta.bend.snap ├── compile_file_o_all__unscoped_eta.bend.snap ├── compile_file_o_all__var_shadows_ref.bend.snap ├── compile_file_o_all__weekday.bend.snap ├── compile_file_o_no_all__bitonic_sort.bend.snap ├── compile_file_o_no_all__list_reverse.bend.snap ├── compile_file_o_no_all__redex_order.bend.snap ├── compile_file_o_no_all__sum_tree.bend.snap ├── compile_long__huge_tree.bend.snap ├── compile_long__long_str_file.bend.snap ├── desugar_file__ask_branch.bend.snap ├── desugar_file__bind_syntax.bend.snap ├── desugar_file__combinators.bend.snap ├── desugar_file__deref_loop.bend.snap ├── desugar_file__dup_linearization.bend.snap ├── desugar_file__local_def_shadow.bend.snap ├── desugar_file__main_aux.bend.snap ├── desugar_file__mapper_syntax.bend.snap ├── desugar_file__switch_with_use.bend.snap ├── desugar_file__tree_syntax.bend.snap ├── desugar_file__use_id.bend.snap ├── desugar_file__use_shadow.bend.snap ├── desugar_file__used_once_names.bend.snap ├── encode_pattern_match__adt_tup_era.bend.snap ├── encode_pattern_match__and3.bend.snap ├── encode_pattern_match__bool.bend.snap ├── encode_pattern_match__bool_tup.bend.snap ├── encode_pattern_match__box.bend.snap ├── encode_pattern_match__common.bend.snap ├── encode_pattern_match__concat.bend.snap ├── encode_pattern_match__concat_def.bend.snap ├── encode_pattern_match__def_tups.bend.snap ├── encode_pattern_match__definition_merge.bend.snap ├── encode_pattern_match__expr.bend.snap ├── encode_pattern_match__flatten_era_pat.bend.snap ├── encode_pattern_match__full_map.bend.snap ├── encode_pattern_match__is_some_some.bend.snap ├── encode_pattern_match__list_merge_sort.bend.snap ├── encode_pattern_match__list_str_encoding_undeclared_fn.bend.snap ├── encode_pattern_match__list_str_encoding_undeclared_map.bend.snap ├── encode_pattern_match__match_adt_unscoped_in_arm.bend.snap ├── encode_pattern_match__match_adt_unscoped_lambda.bend.snap ├── encode_pattern_match__match_adt_unscoped_var.bend.snap ├── encode_pattern_match__match_auto_linearization.bend.snap ├── encode_pattern_match__match_bind.bend.snap ├── encode_pattern_match__match_num_adt_tup_parser.bend.snap ├── encode_pattern_match__match_num_pred.bend.snap ├── encode_pattern_match__match_syntax.bend.snap ├── encode_pattern_match__merge_recursive.bend.snap ├── encode_pattern_match__no_patterns.bend.snap ├── encode_pattern_match__non_matching_fst_arg.bend.snap ├── encode_pattern_match__ntup_sum.bend.snap ├── encode_pattern_match__pattern_match_encoding.bend.snap ├── encode_pattern_match__switch_in_switch_arg.bend.snap ├── encode_pattern_match__var_only.bend.snap ├── encode_pattern_match__weekday.bend.snap ├── examples__bitonic_sort.bend.snap ├── examples__bubble_sort.bend.snap ├── examples__callcc.bend.snap ├── examples__example_fun.bend.snap ├── examples__fib.bend.snap ├── examples__fusing_add.bend.snap ├── examples__fusing_not.bend.snap ├── examples__gen_tree.bend.snap ├── examples__hello_world.bend.snap ├── examples__insertion_sort.bend.snap ├── examples__list.bend.snap ├── examples__parallel_and.bend.snap ├── examples__parallel_hello_world.bend.snap ├── examples__parallel_sum.bend.snap ├── examples__queue.bend.snap ├── examples__quick_sort.bend.snap ├── examples__radix_sort.bend.snap ├── import_system__import_ctr_syntax.bend.snap ├── import_system__import_main.bend.snap ├── import_system__import_main2.bend.snap ├── import_system__import_main3.bend.snap ├── import_system__import_type.bend.snap ├── import_system__import_types.bend.snap ├── import_system__imports.bend.snap ├── import_system__imports_alias.bend.snap ├── import_system__imports_alias_shadow.bend.snap ├── import_system__imports_conflict.bend.snap ├── import_system__imports_file_and_dir.bend.snap ├── import_system__imports_file_and_dir_conflict.bend.snap ├── import_system__imports_shadow.bend.snap ├── import_system__imports_shadow2.bend.snap ├── io__load.bend.snap ├── io__load_fail.bend.snap ├── io__read_line_eof.bend.snap ├── io__store.bend.snap ├── io__store_fail.bend.snap ├── io__utf8.bend.snap ├── linear_readback__church_mul.bend.snap ├── mutual_recursion__a_b_c.bend.snap ├── mutual_recursion__len.bend.snap ├── mutual_recursion__merged.bend.snap ├── mutual_recursion__multiple.bend.snap ├── mutual_recursion__odd_even.bend.snap ├── parse_file__bad_floating.bend.snap ├── parse_file__bend_missing_else.bend.snap ├── parse_file__era.bend.snap ├── parse_file__fold_missing_case.bend.snap ├── parse_file__fun_def.bend.snap ├── parse_file__fun_def_name.bend.snap ├── parse_file__if_missing_else.bend.snap ├── parse_file__imp_map.bend.snap ├── parse_file__imp_program.bend.snap ├── parse_file__match_missing_case.bend.snap ├── parse_file__multi_line_comment.bend.snap ├── parse_file__redefinition_builtin.bend.snap ├── parse_file__redefinition_ctr_with_fun.bend.snap ├── parse_file__redefinition_fun_imp.bend.snap ├── parse_file__redefinition_imp_fun.bend.snap ├── parse_file__redefinition_type_with_object.bend.snap ├── parse_file__redefinition_with_def_between.bend.snap ├── parse_file__redefinition_with_object_between.bend.snap ├── parse_file__redefinition_with_type_between.bend.snap ├── parse_file__repeated_adt_name.bend.snap ├── parse_file__repeated_datatype_name.bend.snap ├── parse_file__scape_chars.bend.snap ├── parse_file__strange_pattern.bend.snap ├── parse_file__tab.bend.snap ├── parse_file__tup_with_signed.bend.snap ├── parse_file__tuple_assign.bend.snap ├── parse_file__tuple_commas.bend.snap ├── parse_file__tuple_need_parens.bend.snap ├── prelude__applies_function_to_map.bend.snap ├── prelude__get_values_from_map.bend.snap ├── prelude__lists_to_map.bend.snap ├── prelude__map_checked_test.bend.snap ├── prelude__map_contains_test.bend.snap ├── prelude__set_node_when_empty.bend.snap ├── readback_hvm__addition.bend.snap ├── readback_hvm__bad_net.bend.snap ├── readback_hvm__bad_net1.bend.snap ├── readback_hvm__bad_net3.bend.snap ├── readback_hvm__complicated_dup.bend.snap ├── readback_hvm__fst_snd.bend.snap ├── readback_hvm__id.bend.snap ├── readback_hvm__invalid_op2_op2.bend.snap ├── readback_hvm__match.bend.snap ├── readback_hvm__nested_let.bend.snap ├── readback_hvm__nested_tup.bend.snap ├── readback_hvm__number.bend.snap ├── readback_hvm__simple_tup.bend.snap ├── readback_hvm__tup_add.bend.snap ├── run_file__360_no_scope.bend.snap ├── run_file__addition.bend.snap ├── run_file__adt_match.bend.snap ├── run_file__adt_match_wrong_tag.bend.snap ├── run_file__adt_option_and.bend.snap ├── run_file__adt_wrong_tag.bend.snap ├── run_file__and.bend.snap ├── run_file__basic_num_ops.bend.snap ├── run_file__bend_fold.bend.snap ├── run_file__bitonic_sort.bend.snap ├── run_file__bitonic_sort_lam.bend.snap ├── run_file__box.bend.snap ├── run_file__branch_statements_assignment.bend.snap ├── run_file__callcc.bend.snap ├── run_file__chars.bend.snap ├── run_file__chars_forall.bend.snap ├── run_file__chars_lambda.bend.snap ├── run_file__checked_scott_encoding.bend.snap ├── run_file__comprehension.bend.snap ├── run_file__def_bool_num.bend.snap ├── run_file__def_num_bool.bend.snap ├── run_file__def_tups.bend.snap ├── run_file__do_block_mixed.bend.snap ├── run_file__dup_global_lam.bend.snap ├── run_file__empty.bend.snap ├── run_file__encode_decode_utf8.bend.snap ├── run_file__erased_side_effect.bend.snap ├── run_file__escape_sequences.bend.snap ├── run_file__eta.bend.snap ├── run_file__example.bend.snap ├── run_file__exp.bend.snap ├── run_file__expand_main_combinator.bend.snap ├── run_file__expand_main_list.bend.snap ├── run_file__extracted_match_pred.bend.snap ├── run_file__filter_bool_id.bend.snap ├── run_file__floating_numbers.bend.snap ├── run_file__fold_with_state.bend.snap ├── run_file__guide_bend_7tree.bend.snap ├── run_file__guide_bend_sequential.bend.snap ├── run_file__guide_bend_sum_tree.bend.snap ├── run_file__guide_bitonic_sort.bend.snap ├── run_file__guide_circle_area.bend.snap ├── run_file__guide_distance_4args.bend.snap ├── run_file__guide_distance_obj.bend.snap ├── run_file__guide_distance_tup.bend.snap ├── run_file__guide_enumerate.bend.snap ├── run_file__guide_if_age.bend.snap ├── run_file__guide_is_even_num.bend.snap ├── run_file__guide_is_even_str.bend.snap ├── run_file__guide_list_ctrs.bend.snap ├── run_file__guide_list_match.bend.snap ├── run_file__guide_list_sugar.bend.snap ├── run_file__guide_mul2_inline.bend.snap ├── run_file__guide_mul2_rec.bend.snap ├── run_file__guide_shader_dummy.bend.snap ├── run_file__guide_sum.bend.snap ├── run_file__hvm_def_cast.bend.snap ├── run_file__hvm_def_two_defs.bend.snap ├── run_file__id_underscore.bend.snap ├── run_file__imp_empty_literals.bend.snap ├── run_file__imp_use_statement.bend.snap ├── run_file__kind_compiled_tree_sum.bend.snap ├── run_file__lam_op2.bend.snap ├── run_file__lam_op2_nested.bend.snap ├── run_file__let_tup_readback.bend.snap ├── run_file__linearize_match.bend.snap ├── run_file__list_resugar.bend.snap ├── run_file__list_reverse.bend.snap ├── run_file__list_reverse_imp.bend.snap ├── run_file__list_take.bend.snap ├── run_file__list_to_tree.bend.snap ├── run_file__mapper_syntax.bend.snap ├── run_file__match.bend.snap ├── run_file__match_builtins.bend.snap ├── run_file__match_mult_linearization.bend.snap ├── run_file__match_num_adt_tup_parser.bend.snap ├── run_file__match_num_explicit_bind.bend.snap ├── run_file__match_num_num_to_char.bend.snap ├── run_file__match_num_succ_complex.bend.snap ├── run_file__match_str.bend.snap ├── run_file__match_sup.bend.snap ├── run_file__match_vars.bend.snap ├── run_file__math.bend.snap ├── run_file__merge_sort.bend.snap ├── run_file__mixed_syntax.bend.snap ├── run_file__names_hyphen.bend.snap ├── run_file__names_hyphen_toplevel.bend.snap ├── run_file__nat_add.bend.snap ├── run_file__nat_add_num.bend.snap ├── run_file__nested_list_and_string.bend.snap ├── run_file__nested_map_get.bend.snap ├── run_file__nested_map_set.bend.snap ├── run_file__nested_str.bend.snap ├── run_file__num_cast.bend.snap ├── run_file__num_match_missing_var.bend.snap ├── run_file__num_pred.bend.snap ├── run_file__open.bend.snap ├── run_file__open_object.bend.snap ├── run_file__open_too_many_ctrs.bend.snap ├── run_file__open_undefined_type.bend.snap ├── run_file__ops.bend.snap ├── run_file__override_list_ctr.bend.snap ├── run_file__override_str_ctr.bend.snap ├── run_file__pred.bend.snap ├── run_file__queue.bend.snap ├── run_file__radix_sort_ctr.bend.snap ├── run_file__readback_hvm1_main.bend.snap ├── run_file__readback_list_other_ctr.bend.snap ├── run_file__readback_num_ops.bend.snap ├── run_file__recursive_bind.bend.snap ├── run_file__recursive_combinator.bend.snap ├── run_file__recursive_combinator_nested.bend.snap ├── run_file__recursive_match_native.bend.snap ├── run_file__ref_resolution.bend.snap ├── run_file__repeated_name_truncation.bend.snap ├── run_file__scopeless_discard.bend.snap ├── run_file__str_concat.bend.snap ├── run_file__str_inc.bend.snap ├── run_file__str_inc_eta.bend.snap ├── run_file__str_len.bend.snap ├── run_file__strict_monad_fn.bend.snap ├── run_file__sum_tree.bend.snap ├── run_file__sup_app.bend.snap ├── run_file__sup_reconstruction.bend.snap ├── run_file__superposed_is_even.bend.snap ├── run_file__tagged_lam.bend.snap ├── run_file__tree_to_list.bend.snap ├── run_file__tup_list_strings.bend.snap ├── run_file__tup_reconstruction.bend.snap ├── run_file__tuple_eta.bend.snap ├── run_file__tuple_rots.bend.snap ├── run_file__unaplied_str.bend.snap ├── run_file__unbound_wrap.bend.snap ├── run_file__unscoped_never_used.bend.snap ├── run_file__unused_dup_var.bend.snap ├── run_file__unused_main_var.bend.snap ├── run_file__world.bend.snap ├── run_file__wrong_string.bend.snap ├── scott_triggers_unused__test.bend.snap ├── simplify_matches__adt_tup_era.bend.snap ├── simplify_matches__already_flat.bend.snap ├── simplify_matches__bits_dec.bend.snap ├── simplify_matches__complex_with_case.bend.snap ├── simplify_matches__double_unwrap_box.bend.snap ├── simplify_matches__double_unwrap_maybe.bend.snap ├── simplify_matches__flatten_with_terminal.bend.snap ├── simplify_matches__irrefutable_case.bend.snap ├── simplify_matches__linearize_match_all.bend.snap ├── simplify_matches__match_str.bend.snap ├── simplify_matches__nested.bend.snap ├── simplify_matches__nested2.bend.snap ├── simplify_matches__nested_0ary.bend.snap ├── simplify_matches__redundant_with_era.bend.snap └── simplify_matches__wrong_fn_arity.bend.snap ================================================ FILE CONTENTS ================================================ ================================================ FILE: .github/ISSUE_TEMPLATE/bug_report.yml ================================================ name: Bug report description: Create a report to help us improve. body: - type: markdown attributes: value: | ### Bug Report Your issue might have been already reported. Please check the [frequently asked questions](https://github.com/HigherOrderCO/Bend/blob/main/FAQ.md) first, especially if you're having trouble installing or running the GPU runtime. Then, please check the [existing issues](https://github.com/HigherOrderCO/Bend/issues) to see if someone else already reported it. If you find a similar issue, respond with a reaction or any additional information that you feel may be helpful. Before opening a new issue, make sure that your Bend and HVM versions are up-to-date. ### For Windows Users There is currently no native way to make Bend work on windows, as a temporary workaround, please use [WSL2](https://learn.microsoft.com/en-us/windows/wsl/install). - type: textarea attributes: label: Reproducing the behavior description: A clear and concise description of what the bug is. value: | Example: Running command... With code.... Error... Expected behavior.... validations: required: true - type: textarea attributes: label: System Settings description: Your System's settings value: | Example: - HVM: [e.g. HVM 2.0.13] - Bend: [e.g. 0.2.11] - OS: [e.g. Linux (Ubuntu 22.04)] - CPU: [e.g. Intel i9-14900KF] - GPU: [e.g. RTX 4090] - Cuda Version [e.g. release 12.4, V12.4.131] validations: required: true - type: textarea attributes: label: Additional context description: Add any other context about the problem here (Optional). ================================================ FILE: .github/ISSUE_TEMPLATE/config.yml ================================================ blank_issues_enabled: false contact_links: - name: HVM Related Issues url: https://github.com/HigherOrderCO/HVM/issues/new/choose about: For HVM related Issues, please Report them on the HVM repository. ================================================ FILE: .github/ISSUE_TEMPLATE/feature_request.md ================================================ --- name: Feature request about: Suggest a feature that you think should be added. title: '' labels: '' assignees: '' --- **Is your feature request related to a problem? Please describe.** A clear and concise description of what the problem is. Ex. I'm frustrated when [...] **Describe the solution you'd like** A clear and concise description of what you want to happen. **Describe alternatives you've considered** A clear and concise description of any alternative solutions or features you've considered. **Additional context** Add any other context or screenshots about the feature request here. ================================================ FILE: .github/workflows/checks.yml ================================================ name: Checks on: pull_request: merge_group: push: branches: - main jobs: check: runs-on: ubuntu-latest timeout-minutes: 10 steps: - uses: actions/checkout@v3 - uses: dtolnay/rust-toolchain@stable - uses: actions/cache@v2 with: path: | ~/.cargo/registry ~/.cargo/git target key: ${{ runner.os }}-check-${{ hashFiles('**/Cargo.lock') }} - run: RUSTFLAGS="-D warnings" cargo check --all-targets test: runs-on: ubuntu-latest timeout-minutes: 10 steps: - uses: actions/checkout@v3 - uses: dtolnay/rust-toolchain@stable - uses: actions/cache@v2 with: path: | ~/.cargo/registry ~/.cargo/git target key: ${{ runner.os }}-test-${{ hashFiles('**/Cargo.lock') }} - run: cargo install hvm - run: cargo test -- --test-threads=1 clippy: runs-on: ubuntu-latest timeout-minutes: 10 steps: - uses: actions/checkout@v3 - uses: dtolnay/rust-toolchain@stable with: components: clippy - uses: actions/cache@v2 with: path: | ~/.cargo/registry ~/.cargo/git target key: ${{ runner.os }}-clippy-${{ hashFiles('**/Cargo.lock') }} - run: RUSTFLAGS="-D warnings" cargo clippy fmt: runs-on: ubuntu-latest timeout-minutes: 10 steps: - uses: actions/checkout@v3 - uses: dtolnay/rust-toolchain@stable with: components: rustfmt - run: cargo fmt --check cspell: runs-on: ubuntu-latest timeout-minutes: 10 steps: - uses: actions/checkout@v3 - uses: streetsidesoftware/cspell-action@v5 with: incremental_files_only: false config: ./cspell.json files: | **/*.rs **/*.md ================================================ FILE: .gitignore ================================================ /target *.snap.new .out.hvm .DS_Store .vscode ================================================ FILE: .rustfmt.toml ================================================ edition = "2021" max_width = 110 # won't add \r\n on windows machines, better on diffs newline_style = "Unix" use_small_heuristics = "Max" tab_spaces = 2 use_field_init_shorthand = true use_try_shorthand = true ================================================ FILE: CHANGELOG.md ================================================ # Changelog All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project does not currently adhere to a particular versioning scheme. ## [0.2.38] - 2025-02-23 ### Added - Emit a warning when a rule in a pattern matching function is unreachable. ([#736][gh-736]) ### Fixed - Fix type checker not properly unifying all the arms of a match expression. ([#734][gh-734]) - Fix signed numbers (i24 and f24) not being parsed after parenthesis `(`. ([#748][gh-748]) ## [0.2.37] - 2024-10-18 ### Fixed - Fix variable binding in pattern matching when the irrefutable pattern optimization occurs. ([#618][gh-618]) - Don't warn on unused generated definitions. ([#514][gh-514]) - Fix local definitions not being desugared properly. ([#623][gh-623]) - Expand references to functions generated by the `float_combinators` pass inside the main function. ([#642][gh-642]) - Expand references inside constructors in the main function. ([#643][gh-643]) - Fix readback when hvm net has `a{n}` or `x{n}` vars. ([#659][gh-659]) - Fix imported constructors not being updated to Constructor expression. ([#674][gh-674]) - Fix parse error on parenthesized eraser. ([#675][gh-675]) - Fix IO/FS/read_line when the line ends with a EOF. ([#638][gh-638]) - Fix lambda body being parsed as tuple in imp syntax. ([#706][gh-706]) ### Added - Add type system for Bend. ([#615][gh-615], [#679][gh-679], see [Type Checking](docs/type-checking.md)) - Add import system. ([#544][gh-544]) - Add multi line comment `#{ ... #}` syntax. ([#595][gh-595]) - Add error message when input file is not found. ([#513][gh-513]) - Add `List/filter` and `String/{equals, filter}` builtins. - Add IO functions for loading dynamically linked libraries (`IO/DyLib/open`, `IO/DyLib/call`, `IO/DyLib/close`). ([#621][gh-621]) ### Changed - Change tuple syntax to not require parentheses in some cases. ([#554][gh-554]) - Improve error messages in branching statements. ([#464][gh-464]) - Change branches to support ending with ask statements. ([#629][gh-629]) - Improve hexadecimal and binary floating numbers. ([#648][gh-648]) - Change IO functions to return Result. ([#657][gh-657]) - Revamp the diagnostics system and parser to show more error and warning messages ([#673][gh-673]) ## [0.2.36] - 2024-07-04 ### Changed - Improve error messages for redefinition of types and objects. ([#485][gh-485]) - Don't allow tabs to be used for indentation or spacing. ([#463][gh-463]) - Rename builtin function `sleep` to `IO/nanosleep`. ([#581][gh-581]) - Equational number pattern compilation to use the predecessor variable when possible. ([#470][gh-470]) - Rename `Bytes/decode_utf8` to `String/decode_utf8` and `Bytes/decode_ascii` to `String/decode_ascii`. - Rename `log` to `Math/log` and `atan2` to `Math/atan2`. ### Fixed - Fix readback of numeric operations. ([#467][gh-467]) - Propagate the "builtin" attribute of definitions when extracting functions from `bend` and `fold` syntax. - Panic while using unscoped variables on definition patterns. ([#468][gh-468]) ### Added - Create new type of top-level definition for writing native HVM definitions. ([#586][gh-586]) - Add `log` and `atan2` builtin functions. ([#583][gh-583]) - Add `to_f24`, `to_u24` and `to_i24` number casting builtin functions. ([#582][gh-582]) - Add `IO/sleep` builtin function to sleep for a given amount of seconds as a float. ([#581][gh-581]) - Add primitive file IO functions `IO/FS/{read, write, seek, open, close}`. ([#573][gh-573]) - Add encoding/decoding builtin functions `Bytes/{decode_utf8, decode_ascii} String/{encode_ascii, decode_ascii} Utf8/{decode_character, REPLACEMENT_CHARACTER}`. ([#580][gh-580]) - Add `IO/print` function to print to stdout. ([#579][gh-579]) - Add `IO/input` function to read a line of input from stdin. ([#579][gh-579]) - Add file IO utilities `IO/FS/{read_file, write_file, read_line, read_to_end}`. ([#578][gh-578]) - Add list utilities `List/{length, reverse, flatten, concat}`. - Add `elif` chains to functional syntax. ([#596][gh-596]) - Add local definitions to imperative syntax. ([#562][gh-562]) - Add local definitions to functional syntax. - Add repeated field name error message. - Add `Math` builtin functions. ([#570][gh-570]) - Add primitive file IO function `IO/FS/flush`. ([#598][gh-598]) - Changed `bend run` to `bend run-rs` and `bend run` defaults to the C implementation. ([#620][gh-620]) ## [0.2.35] - 2024-06-06 ### Changed - Make lambda `Term` with bind patterns display as `let` terms. ([#466][gh-466]) ## [0.2.34] - 2024-06-05 ### Added - Add syntax for "less than or equal" `<=` and "greater than or equal" `>=` numeric operators. ([#451][gh-451]) ## [0.2.33] - 2024-06-05 ### Added - Implement `expand_main`, a compilation pass that expands references in the entry point function. ([#424][gh-424]) ### Changed - Make the `float_combinators` pass no longer extract in the entry point function. ([#424][gh-424]) ## [0.2.32] - 2024-06-05 ### Added - Implement the built-in `Tree` datatype. ([#528][gh-528]) - Implement `![]` and `!` syntax for `Tree` literals. ([#528][gh-528]) - Create a changelog. ### Changed - Move the builtins documentation to `/docs`. ## [0.2.30] - 2024-06-04 ### Changed - No longer expand generated recursive definitions. ([#502][gh-502]) ## [0.2.29] - 2024-06-04 ### Added - Support custom HVM binaries. ([#479][gh-479]) ### Changed - Make monadic blocks lazy by deferring execution of continuations with free vars. ([#526][gh-526]) ## [0.2.28] - 2024-05-30 ### Added - Support mapper statements. ([#465][gh-465]) ## [0.2.27] - 2024-05-29 ### Changed - Make `with` clauses take a bind and an argument. ([#516][gh-516]) ## [0.2.26] - 2024-05-28 ### Changed - `do` keyword to `with`. ([#494][gh-494]) ### Added - `wrap` alias inside `with` blocks. ([#494][gh-494]) ## [0.2.25] - 2024-05-28 ### Added - Generated constructor tags. ([#512][gh-512]) ## [0.2.24] - 2024-05-27 ### Added - `elif` chains. ([#427][gh-427]) ## [0.2.23] - 2024-05-27 ### Fixed - `gen-cu` and `gen-c` commands after move to HVM syntax tree. ## [0.2.22] - 2024-05-26 ### Changed - Rust channel from `nightly` to `stable`. ([#486][gh-486]) ## [0.2.21] - 2024-05-25 ### Changed - HVM syntax tree for representing inets inside the compiler. ([#475][gh-475]) ## [0.2.20] - 2024-05-24 ### Fixed - Map getters generation inside map setters. ([#489][gh-489]) ## [0.2.19] - 2024-05-24 ### Changed - Variable names to not allow `__`. ([#478][gh-478]) ## [0.2.18] - 2024-05-24 ### Fixed - Nested map getters generation. ([#483][gh-483]) ## [0.2.17] - 2024-05-23 ### Changed - Top-level names to not start with `//`. ([#443][gh-443]) ## [0.2.16] - 2024-05-23 ### Added - New `IO` builtins. ### Fixed - Definition pruning transformation. ## [0.2.15] - 2024-05-22 ### Fixed - Exponentiation miscompilation. ([#444][gh-444]) ## [0.2.14] - 2024-05-22 ### Changed - Inet level eta-reduction pass to not reduce number nodes. ## [0.2.13] - 2024-05-22 ### Fixed - Scope of `fork`. ## [0.2.12] - 2024-05-22 ### Changed - Functional syntax `data` keyword to `type`. ## [0.2.11] - 2024-05-22 ### Added - List comprehension. - Bit shift left and Bit shift right. ## [0.2.10] - 2024-05-21 ### Changed - Numbers to new HVM number operation format. - Rules definition to be in a single block. - Disabled `net-size` check by default. ## [0.2.9] - 2024-05-19 ### Changed - Readback error messages. ## [0.2.8] - 2024-05-19 ### Changed - Increase max net size. - `check-net-size` to be optional. ## [0.2.7] - 2024-05-17 ### Added - Apache-2.0 License. ## [0.2.6] - 2024-05-17 ### Added - Simple readback of tuples. ### Changed - Imperative syntax to require `,` in list-like builtins. ### Fixed - Empty map parsing. ## [0.2.5] - 2024-05-16 ### Added - Exponentiation `**` operator. ### Changed - `go` to `fork` inside `bend` statement. ## [0.2.4] - 2024-05-15 ### Changed - New version for hvm-core compatibility. ## [0.2.3] - 2024-05-15 ### Changed - Rename to `bend-lang`. - Use crates.io HVM. ### Added - List readback. ## [0.2.2] - 2024-05-15 ### Changed - Comments from `//` to `#`. - Lambda syntax and built-in constructor names. - Fold to require explicit state passing. ### Added - Record types and destructuring. - String readback. ## [0.2.1] - 2024-05-15 ### Fixed - Number parsing in imperative syntax. ### Changed - Require `\n` after return. ## [0.2.0] - 2024-05-14 - Initial public release of Bend. [0.2.0]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.0 [0.2.1]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.1 [0.2.2]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.2 [0.2.3]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.3 [0.2.4]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.4 [0.2.5]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.5 [0.2.6]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.6 [0.2.7]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.7 [0.2.8]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.8 [0.2.9]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.9 [0.2.10]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.10 [0.2.11]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.11 [0.2.12]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.12 [0.2.13]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.13 [0.2.14]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.14 [0.2.15]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.15 [0.2.16]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.16 [0.2.17]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.17 [0.2.18]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.18 [0.2.19]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.19 [0.2.20]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.20 [0.2.21]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.21 [0.2.22]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.22 [0.2.23]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.23 [0.2.24]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.24 [0.2.25]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.25 [0.2.26]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.26 [0.2.27]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.27 [0.2.28]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.28 [0.2.29]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.29 [0.2.30]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.30 [0.2.32]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.32 [0.2.33]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.33 [0.2.34]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.34 [0.2.35]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.35 [0.2.36]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.36 [0.2.37]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.37 [0.2.38]: https://github.com/HigherOrderCO/Bend/releases/tag/0.2.38 [gh-424]: https://github.com/HigherOrderCO/Bend/issues/424 [gh-427]: https://github.com/HigherOrderCO/Bend/issues/427 [gh-443]: https://github.com/HigherOrderCO/Bend/issues/443 [gh-444]: https://github.com/HigherOrderCO/Bend/issues/444 [gh-451]: https://github.com/HigherOrderCO/Bend/issues/451 [gh-463]: https://github.com/HigherOrderCO/Bend/issues/463 [gh-464]: https://github.com/HigherOrderCO/Bend/issues/464 [gh-465]: https://github.com/HigherOrderCO/Bend/issues/465 [gh-466]: https://github.com/HigherOrderCO/Bend/issues/466 [gh-467]: https://github.com/HigherOrderCO/Bend/issues/467 [gh-468]: https://github.com/HigherOrderCO/Bend/issues/468 [gh-470]: https://github.com/HigherOrderCO/Bend/issues/470 [gh-475]: https://github.com/HigherOrderCO/Bend/issues/475 [gh-478]: https://github.com/HigherOrderCO/Bend/issues/478 [gh-479]: https://github.com/HigherOrderCO/Bend/issues/479 [gh-483]: https://github.com/HigherOrderCO/Bend/issues/483 [gh-485]: https://github.com/HigherOrderCO/Bend/issues/485 [gh-486]: https://github.com/HigherOrderCO/Bend/issues/486 [gh-489]: https://github.com/HigherOrderCO/Bend/issues/489 [gh-494]: https://github.com/HigherOrderCO/Bend/issues/494 [gh-502]: https://github.com/HigherOrderCO/Bend/issues/502 [gh-512]: https://github.com/HigherOrderCO/Bend/issues/512 [gh-513]: https://github.com/HigherOrderCO/Bend/issues/513 [gh-514]: https://github.com/HigherOrderCO/Bend/issues/514 [gh-516]: https://github.com/HigherOrderCO/Bend/issues/516 [gh-526]: https://github.com/HigherOrderCO/Bend/issues/526 [gh-528]: https://github.com/HigherOrderCO/Bend/issues/528 [gh-544]: https://github.com/HigherOrderCO/Bend/pull/544 [gh-554]: https://github.com/HigherOrderCO/Bend/issues/554 [gh-562]: https://github.com/HigherOrderCO/Bend/issues/562 [gh-570]: https://github.com/HigherOrderCO/Bend/issues/570 [gh-573]: https://github.com/HigherOrderCO/Bend/issues/573 [gh-578]: https://github.com/HigherOrderCO/Bend/issues/578 [gh-579]: https://github.com/HigherOrderCO/Bend/issues/579 [gh-580]: https://github.com/HigherOrderCO/Bend/issues/580 [gh-581]: https://github.com/HigherOrderCO/Bend/issues/581 [gh-582]: https://github.com/HigherOrderCO/Bend/issues/582 [gh-583]: https://github.com/HigherOrderCO/Bend/issues/583 [gh-586]: https://github.com/HigherOrderCO/Bend/issues/586 [gh-595]: https://github.com/HigherOrderCO/Bend/issues/595 [gh-596]: https://github.com/HigherOrderCO/Bend/issues/596 [gh-598]: https://github.com/HigherOrderCO/Bend/issues/598 [gh-618]: https://github.com/HigherOrderCO/Bend/issues/618 [gh-620]: https://github.com/HigherOrderCO/Bend/issues/620 [gh-621]: https://github.com/HigherOrderCO/Bend/issues/621 [gh-623]: https://github.com/HigherOrderCO/Bend/issues/623 [gh-629]: https://github.com/HigherOrderCO/Bend/issues/629 [gh-638]: https://github.com/HigherOrderCO/Bend/issues/638 [gh-642]: https://github.com/HigherOrderCO/Bend/issues/642 [gh-643]: https://github.com/HigherOrderCO/Bend/issues/643 [gh-648]: https://github.com/HigherOrderCO/Bend/issues/648 [gh-657]: https://github.com/HigherOrderCO/Bend/issues/657 [gh-659]: https://github.com/HigherOrderCO/Bend/pull/659 [gh-673]: https://github.com/HigherOrderCO/Bend/pull/673 [gh-674]: https://github.com/HigherOrderCO/Bend/issues/674 [gh-675]: https://github.com/HigherOrderCO/Bend/issues/675 [gh-706]: https://github.com/HigherOrderCO/Bend/issues/706 [gh-734]: https://github.com/HigherOrderCO/Bend/issues/734 [gh-736]: https://github.com/HigherOrderCO/Bend/issues/736 [gh-748]: https://github.com/HigherOrderCO/Bend/issues/748 ================================================ FILE: CONTRIBUTING.md ================================================ # Contributing to Bend Thank you for considering contributing to Bend! ## How to Contribute ### Reporting bugs 1. **Check for existing issues:** Before you create a new issue, please do a search in [our issues](https://github.com/HigherOrderCO/Bend/issues) to see if the issue or feature request has already been filed. 2. **Create a new issue:** If you find no issue or your issue differs, [create a new issue](https://github.com/HigherOrderCO/Bend/issues/new?template=bug_report.yml) and provide detailed information, including steps to reproduce the problem. ### Suggesting Enhancements 1. **Check for existing suggestions:** Before suggesting a new feature, please check if it's already been suggested in [our issues](https://github.com/HigherOrderCO/Bend/issues). 2. **Create a new suggestion:** If you find no similar suggestion, [create a new suggestion issue](https://github.com/HigherOrderCO/Bend/issues/new?template=feature_request.md) and provide detailed information about the enhancement and why it would be useful. ### Checking HVM Issues Since Bend depends on HVM, some issues might be related to HVM rather than Bend itself. Please also check the [HVM issues page](https://github.com/HigherOrderCO/HVM/issues) to see if your issue has already been reported there. ### Submitting Changes 1. **Fork the repository:** Create your own fork of the repository on GitHub. 2. **Create a new branch:** Make your changes in a new branch in your forked repository. 3. **Run formatting and linting checks:** Before submitting your changes, ensure your code is properly formatted and linted: - Run `cargo fmt` to format your code. - Run `cargo clippy` to lint your code. 4. **Run tests:** Ensure all tests pass and update any test results: - Run `cargo insta test` to run the tests. > If insta is not available as a cargo command, install it using `cargo install cargo-insta`. - Run `cargo insta review` to save any changes to the test results. 5. **Submit a pull request:** Once your changes are ready, submit a pull request from your branch to the `main` branch of the Bend Repository We appreciate every contribution! ================================================ FILE: Cargo.toml ================================================ [package] name = "bend-lang" description = "A high-level, massively parallel programming language" license = "Apache-2.0" version = "0.2.38" edition = "2021" rust-version = "1.74" exclude = ["tests/"] [lib] name = "bend" path = "src/lib.rs" [[bin]] name = "bend" path = "src/main.rs" required-features = ["cli"] [profile.release] lto = true [features] default = ["cli"] cli = ["dep:clap"] [dependencies] TSPL = "0.0.13" clap = { version = "4.4.1", features = ["derive"], optional = true } highlight_error = "0.1.1" hvm = "=2.0.22" indexmap = "2.2.3" interner = "0.2.1" itertools = "0.11.0" loaned = "0.1.0" stacker = "0.1" [dev-dependencies] insta = "1.34.0" stdext = "0.3.1" walkdir = "2.3.3" [profile.test] opt-level = 2 ================================================ FILE: FAQ.md ================================================ # Known Issues and Frequently Asked Questions ## Installation and Setup ### Can I run this on Windows? - We're still working on the windows support, for the moment, please use [WSL2](https://learn.microsoft.com/en-us/windows/wsl/install). ### I'm getting a `CUDA not available!` error even though I have it installed? - CUDA support is enable only during installation. If you first installed HVM and then installed CUDA and `nvcc`, please try to install HVM again. ### I'm getting a `Failed to launch kernels (error code invalid argument)!` error. - The current iteration of the `hvm.cu` was written with the RTX 4090 in mind, and won't work on older GPUs, since they contain about half of the newer GPUs shared memory, for better understanding please refer to [HVM#283](https://github.com/HigherOrderCO/HVM/issues/283). We are working on support for older GPUs and will release it soon. ### I get "Command `bend` not found" after installing, what do I do? - If you are on Unix system (or WSL) then most likely bend did not add itself to the PATH variable in your rc file. To remedy this: - Determine if you are using bash or zsh (check for presence of `~/.bashrc` or `~/.zshrc`) - Make change to the relevant file by running `echo -n 'export PATH=$PATH:$HOME/.cargo/bin' >> ~/.bashrc` - use `~/.zshrc` in place of `~/.bashrc` in the case you are on zsh system - You will then need to run `source ~/.bashrc` or `source ~/.zshrc` for the changes to take effect immediately - Try running `bend` once more - it should work now! ### I got an error when installing HVM on Linux - If the error happens when compiling the CUDA runtime or contains anything regarding `ccbin`, please refer to [HVM#291](https://github.com/HigherOrderCO/HVM/issues/291). - If the error contains anything regarding `libc` missing, please refer to [HVM#355](https://github.com/HigherOrderCO/Bend/issues/355) ### Can I run this on AMD/Intel/Apple GPUs? - We plan on adding support to many other GPUs as soon as the CUDA version is sufficiently stable. ### What GPUs are supported? GPUs with >=96KB L1 cache per SM *should* work. This includes the following: | GPU | Tested? | |-----------------------------|---------| | RTX 4090 | Yes | | All Other Desktop 40 Series | No | | All Desktop 30 Series | No | | All Mobile 40 Series | No | | All Mobile 30 Series | No | ## Using Bend ### How do I use IO? - IO is still being developed and is expected to come soon. ### How to do FFI? - Not as soon as basic IO, but planned or at least something similar to FFI. ### Are there any Libraries, Packages etc? - A package manager will be added soon. ### Why are my numbers giving me wrong results? Some possibilities: - Your program is causing an overflow on 24-bit number values. - Your program is doing operations on numbers of different types. (e.g. `2.0 + 1` is not allowed, you must use `2.0 + 1.0`) - Floating point numbers are currently bugged and are interpreted incorrectly in some cases. - There's a bug with signed integers numbers that flips that sometimes flips the order of the operations. ### I'm getting an error of failed assertion - HVM currently has a bug in its conversion of f32 to f24 and it's unable to read the number 0.0. We already have a fix that we're working on. ================================================ FILE: FEATURES.md ================================================ ## Features Bend offers two flavors of syntax, the user-friendly python-like syntax "Imp" (the default) and the core ML/Haskell-like syntax "Fun". You can read the full reference for both of them [here](docs/syntax.md), but these examples will use the first one. To see some more complex examples programs, check out the [examples](examples/) folder. ### Basic features We can start with a basic program that adds the numbers 3 and 2. ```py def main() -> u24: return 2 + 3 ``` Running this program will show the number 5. Be careful with `run` since it will not show any warnings by default. Before running a new program, it's useful to first `check` it. Bend programs consist of a series of function definitions, always starting with a function called `main` or `Main`. Functions can receive arguments both directly and using a lambda abstraction. ```py # These two are equivalent def add(x: u24, y: u24) -> u24: return x + y def add2() -> (u24 -> u24 -> u24): return lambda x, y: x + y ``` You can then call this function like this: ```py def main() -> u24: sum = add(2, 3) return sum ``` ### Data types You can bundle multiple values into a single value using a tuple or a struct. ```py # With a tuple def tuple_fst(x: (a, b)) -> a: # This destructures the tuple into the two values it holds. # '*' means that the value is discarded and not bound to any variable. (fst, *) = x return fst # With an object (similar to what other languages call a struct, a class or a record) object Pair(a, b) { fst: a, snd: b } def Pair/fst(x: Pair(a, b)) -> a: match x: case Pair: return x.fst # We can also access the fields of an object after we `open` it. def Pair/fst_2(x: Pair(a, b)) -> a: open Pair: x return x.fst # This is how we can create new objects. def Pair/with_one(x: a) -> Pair(a, u24): return Pair{ fst: x, snd: 1 } # The function can be named anything, but by convention we use Type/function_name. def Pair/swap(x: Pair(a, b)) -> Pair(b, a): open Pair: x # We can also call the constructor like any normal function. return Pair(x.snd, x.fst) ``` For more complicated data structures, we can use `type` to define algebraic data types. ```py type MyTree: Node { val, ~left, ~right } Leaf ``` This defines a constructor function for each variant of the type, with names `MyTree/Node` and `MyTree/Leaf`. Like most things in bend (except tuples and numbers), types defined with `type` and `object` become lambda encoded functions. You can read how this is done internally by the compiler in [Defining data types](docs/defining-data-types.md) and [Pattern matching](docs/pattern-matching.md). ### Optional typing Types in Bend are completely optional - you can write programs without any type annotations, but we'll be typing every function for clarity. For instace: ```py def main(): sum = add(2, 3) return sum ``` Here, this program will run just fine and return the exact same result as the example shown in [Basic features](#basic-features) ### Pattern matching We can pattern match on values of a data type to perform different actions depending on the variant of the value. ```py def Maybe/or_default(x: Maybe(T), default: T) -> T: match x: case Maybe/Some: # We can access the fields of the variant using 'matched.field' return x.value case Maybe/None: return default ``` ### Folding and bending We use `~` to indicate that a field is recursive. This allows us to easily create and consume these recursive data structures with `bend` and `fold`. `fold` is a recursive `match` that you can use to transform and consume data structures. `bend` is a pure recursive loop that is very useful for generating data structures. ```py #{ Sum all the values in the tree. #} def MyTree.sum(x: MyTree) -> u24: fold x: # The fold is implicitly called for fields marked with '~' in their definition. case MyTree/Node: return x.val + x.left + x.right case MyTree/Leaf: return 0 def main() -> u24: bend val = 0: when val < 10: # 'fork' calls the bend recursively with the provided values. x = MyTree/Node { val:val, left:fork(val + 1), right:fork(val + 1) } else: # 'else' is the base case, when the condition fails. x = MyTree/Leaf return MyTree.sum(x) ``` > Note: since MyTree has no type annotations, its fields will be considered of type `Any`, which partially disables the type checker for these values. Thus the fact that `x` is holding a tree of u24 and not a tree of anything else won't be checked and it's up to the user to make sure it's correct. These are equivalent to inline recursive functions that create a tree and consume it. ```py def MyTree.sum(x: MyTree) -> u24: match x: case MyTree/Node: return x.val + MyTree.sum(x.left) + MyTree.sum(x.right) case MyTree/Leaf: return 0 def main_bend(val: u24) -> MyTree: if val < 10: return MyTree/Node(val, main_bend(val + 1), main_bend(val + 1)) else: return MyTree/Leaf def main() -> u24: x = main_bend(0) return MyTree.sum(x) ``` Making your program around folding trees is a very good way of making it parallelizable, since each core can be dispatched to work on a different branch of the tree. You can also pass some state variables to `fold` just like the variables used in a `bend`. If you give a `fold` some state, then you necessarily need to pass it by calling the folded fields of the matched value, like passing an additional argument to the fold call. ```py # This function substitutes each value in the tree with the sum of all the values before it. def MyTree.map_sum(x: MyTree) -> MyTree: acc = 0 fold x with acc: case MyTree/Node: # `x.left` and `x.right` are called with the new state value. # Note that values are copied if you use them more than once, so you don't want to pass something very large. return MyTree/Node{ val: x.val + acc, left: x.left(x.val + acc), right: x.right(x.val + acc) } case MyTree/Leaf: return x ``` This allows `fold` to be a very powerful and generic tool that can be used to implement most pure data transformations. ### Some caveats and limitations _Attention_: Note that despite the ADT syntax sugars, Bend is an _untyped_ language and the compiler will not stop you from using values incorrectly, which can lead to very unexpected results. For example, the following program will compile just fine even though `!=` is only defined for native numbers: ```py def main(): bend val = [0, 1, 2, 3]: when val != []: match val: case List/Cons: x = val.head + fork(val.tail) case List/Nil: x = 0 else: x = 0 return x ``` Running this program will show `λ* *` and not the expected `6`. It's also important to note that Bend is linear (technically affine), meaning that every variable is only used once. When a variable is used more than once, the compiler will automatically insert a duplication. Duplications efficiently share the same value between two locations, only cloning a value when it's actually needed, but their exact behaviour is slightly more complicated than that and escapes normal lambda-calculus rules. You can read more about it in [Dups and sups](docs/dups-and-sups.md) and learn how pattern matching avoids this problem in [Pattern matching](docs/pattern-matching.md). To use a variable twice without duplicating it, you can use a `use` statement. It inlines clones of some value in the statements that follow it. ```py def foo(x): use result = (1, x) return (result, result) # Is equivalent to def foo(x): return ((1, x), (1, x)) ``` Note that any variable in the `use` will end up being duplicated. Bend supports recursive functions of unrestricted depth: ```py def native_num_to_adt(n: u24) -> Nat: if n == 0: return Nat/Zero else: return Nat/Succ(native_num_to_adt(n - 1)) ``` If your recursive function is not based on pattern matching syntax (like `if`, `match`, `fold`, etc) you have to be careful to avoid an infinite loop. ```py # A scott-encoded list folding function. # Writing it like this will cause an infinite loop. def scott_list.add(xs, add): return xs( λxs.head xs.tail: λc n: (c (xs.head + add), scott_list.add(xs.tail, add))) # Instead we want to write it like this; def scott_list.add(xs, add): return xs( λxs.head xs.tail: λadd: λc n: (c (xs.head + add) scott_list.sum(xs.tail, add)), λadd: λc λn: n, add ) # These functions can't be typed with bend's type system. ``` Since Bend is eagerly executed, some situations will cause function applications to always be expanded, which can lead to looping situations. You can read how to avoid this in [Lazy definitions](docs/lazy-definitions.md). ### Numbers Bend has native numbers and operations. ```py def main() -> (u24, i24, f24): a = 1 # A 24 bit unsigned integer. b = +2 # A 24 bit signed integer. c = -3 # Another signed integer, but with negative value. d = 1.0 # A 24 bit floating point number. e = +0.001 # Also a float. return (a * 2, b - c, d / e) ``` Unsigned numbers are written as just the number. Signed numbers are written with a `+` or `-` sign. Floating point numbers must have the decimal point `.` and can optionally take a sign `+` or `-`. The three number types are fundamentally different. If you mix two numbers of different types HVM will interpret the binary representation of one of them incorrectly, leading to incorrect results. Which number is interpreted incorrectly depends on the situation and shouldn't be relied on for now. You can use `switch` to pattern match on unsigned native numbers: ```py switch x = 4: # From '0' to n, ending with the default case '_'. case 0: "zero" case 1: "one" case 2: "two" # The default case binds the name - # where 'arg' is the name of the argument and 'n' is the next number. # In this case, it's 'x-3', which will have value (4 - 3) = 1 case _: String.concat("other: ", (String.from_num x-3)) ``` You can also convert between the number types using the builtin casting functions. Here's some of the builtin functions you can use to cast any native number into the corresponding type: ```py def main() -> _: x = f24/to_i24(1.0) y = u24/to_f24(2) z = i24/to_u24(-3) return (x, y, z) ``` You can find the other casting functions and their declarations at [builtins.md](docs/builtins.md). ### Other builtin types Bend has Lists and Strings, which support Unicode characters. This is how they are defined: ```py type String: Nil Cons { head: u24, ~tail: String } type List(T): Nil Cons { head: T, ~tail: List(T) } ``` ```py # Here's an example of a List of Strings def main() -> List(String): return ["You: Hello, 🌎", "🌎: Hello, user"] ``` A string is desugared to a String data type containing two constructors, `String/Cons` and `String/Nil`. List also becomes a type with two constructors, `List/Cons` and `List/Nil`. ```py # When you write this def StrEx() -> String: return "Hello" def ids() -> List(u24): return [1, 2, 3] # The compiler converts it to this def StrEx() -> String: return String/Cons('H', String/Cons('e', String/Cons('l', String/Cons('l', String/Cons('o', String/Nil))))) def ids() -> List(u24): return List/Cons(1, List/Cons(2, List/Cons(3, List/Nil))) ``` Characters are delimited by `'` `'` and support Unicode escape sequences. They are encoded as a U24 with the unicode codepoint as their value. ```py # These two are equivalent def chars() -> List(u24): return ['A', '\u{4242}', '🌎'] def chars2() -> List(u24): return [65, 0x4242, 0x1F30E] ``` Bend has a built-in binary tree Map data structure where the key is a `u24` value, meaning you can use numbers, characters, and symbols as keys. Maps are delimited by `{` `}` and its entries are separated by commas. A key-value entry in a map is denoted using a colon `:`. For example: ```py { 42: [4, 2] } # 42 is the key and [4, 2] is the value ``` A Map is desugared to a Map data type containing two constructors `Map/Leaf` and `Map/Node`. ```py # When you write this def empty_map() -> Map(T): return {} def init_map() -> Map(String): return { 1: "one", 2: "two", `blue`: "0x0000FF" } def main() -> String: map = init_map one = map[1] # map getter syntax map[0] = "zero" # map setter syntax return one # The compiler converts it to this def empty_map() -> Map(T): return Map/Leaf def init_map() -> Map(String): map = Map/set(Map/Leaf, 1, "one") map = Map/set(map, 2, "two") return map def main() -> String: map = init_map (one, map) = Map/get(map, 1) map = Map/set(map, 0, "zero") return one # The builtin Map type definition type Map(T): Node { value: Maybe(T), ~left: Map(T), ~right: Map(T) } Leaf ``` Notice that the getter and setter syntax induces an order on things using the map, since every get or set operation depends on the value of the previous map. > **_NOTE:_** Do not get mistaken with lists creation syntax, that also uses `[` `]`. ### Mixing syntaxes As was said in the beginning, Bend offers two flavors of syntax. You can mix and match them freely in your program, as long as each function uses only one flavor. ```py type Bool: True False def is_odd(x: u24) -> Bool: switch x: case 0: return Bool/False case _: return is_even(x-1) is_even(n: u24): u24 = switch n { 0: Bool/True _: (is_odd n-1) } main = (is_odd 20) ``` ### More features Key: - 📗: Basic resources - 📙: Intermediate resources - 📕: Advanced resources Other features are described in the following documentation files: - 📗 Lazy definitions: [Making recursive definitions lazy](docs/lazy-definitions.md) - 📗 Data types: [Defining data types](docs/defining-data-types.md) - 📗 Pattern matching: [Pattern matching](docs/pattern-matching.md) - 📗 Native numbers and operations: [Native numbers](docs/native-numbers.md) - 📗 Builtin definitions: [Builtins](docs/builtins.md) - 📗 CLI arguments: [CLI arguments](docs/cli-arguments.md) - 📙 Duplications and superpositions: [Dups and sups](docs/dups-and-sups.md) - 📙 Scopeless lambdas: [Using scopeless lambdas](docs/using-scopeless-lambdas.md) - 📕 Fusing functions: [Writing fusing functions](docs/writing-fusing-functions.md) ## Further reading - 📙 [Compilation and readback](docs/compilation-and-readback.md) - 📙 [Old HVM wiki learning material](https://github.com/HigherOrderCO/HVM/wiki/HVM-Wiki). It is outdated, but it can still teach you some of the basics. ================================================ FILE: GUIDE.md ================================================ # Bend in X minutes - the ultimate guide! Bend is a high-level, massively parallel programming language. That means it feels like Python, but scales like CUDA. It runs on CPUs and GPUs, and you don't have to do anything to make it parallel: as long as your code isn't "helplessly sequential", it **will** use 1000's of threads! While cool, Bend is far from perfect. In absolute terms it is still not so fast. Compared to SOTA compilers like GCC or GHC, our code gen is still embarrassingly bad, and there is a lot to improve. And, of course, in this beginning, there will be tons of instability and bugs. That said, it does what it promises: scaling horizontally with cores. And that's really cool! If you'd like to be an early adopter of this interesting tech, this guide will teach you how to apply Bend to build parallel programs in a new way! For a more technical dive, check HVM2's [paper](http://paper.HigherOrderCO.com/). For an entertaining, intuitive explanation, see HVM1's classic [HOW.md](https://github.com/HigherOrderCO/HVM/blob/master/guide/HOW.md). But if you just want to dive straight into action - this guide is for you. Let's go! ## Installation ### Install dependencies #### On Linux ```sh # Install Rust if you haven't it already. curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # For the C version of Bend, use GCC. We recommend a version up to 12.x. sudo apt install gcc ``` For the CUDA runtime [install the CUDA toolkit for Linux](https://developer.nvidia.com/cuda-downloads?target_os=Linux) version 12.x. #### On Mac ```sh # Install Rust if you haven't it already. curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # For the C version of Bend, use GCC. We recommend a version up to 12.x. brew install gcc ``` ### Install Bend 1. Install HVM2 by running: ```sh # HVM2 is HOC's massively parallel Interaction Combinator evaluator. cargo install hvm # This ensures HVM is correctly installed and accessible. hvm --version ``` 2. Install Bend by running: ```sh # This command will install Bend cargo install bend-lang # This ensures Bend is correctly installed and accessible. bend --version ``` ## Hello, World! As we said, Bend _feels_ like Python - in some ways. It is high-level, you can easily create objects and lists, there are ifs and loops. Yet, it is different: there is some Haskell in it, in the sense algebraic datatypes, pattern-matching and recursion play an important role. This is how its `"Hello, world!"` looks: ```python def main(): return "Hello, world!" ``` To run the program above, type: ``` bend run-rs main.bend ``` Wait - there is something strange there. Why `return`, not `print`? Well, _for now_ (you'll read these words a lot), Bend's IO is in an experimental stage. We plan on fully introducing it very soon! Nevertheless, here's an example on how you can use IO on bend to print `"Hello, world!"`: ```python def main() -> IO(u24): with IO: * <- IO/print("Hello, world!\n") return wrap(0) ``` To run the program above, type: ``` bend run-c main.bend ``` If all goes well, you should see `"Hello, world!"` in both cases. The `bend run-rs` command uses the reference interpreter, which is slow, whereas the `bend run-c` command uses the much faster C interpreter, but bend can run even faster! In a few moments, we'll teach you how to run your code in parallel, on both CPUs and GPUs. For now, let's learn some fundamentals! ## Basic Functions and Datatypes In Bend, functions are pure: they receive something, and they return something. That's all. Here is a function that tells you how old you are: ```python def am_i_old(age: u24) -> String: if age < 18: return "you're a kid" else: return "you're an adult" def main() -> String: return am_i_old(32) ``` That is simple enough, isn't it? Here is one that returns the euclidean distance between two points: ```python def distance(ax: f24, ay: f24, bx: f24, by: f24) -> f24: dx = bx - ax dy = by - ay return (dx * dx + dy * dy) ** 0.5 def main() -> f24: return distance(10.0, 10.0, 20.0, 20.0) ``` This isn't so pretty. Could we use tuples instead? Yes: ```python def distance(a: (f24, f24), b: (f24, f24)) -> f24: (ax, ay) = a (bx, by) = b dx = bx - ax dy = by - ay return (dx * dx + dy * dy) ** 0.5 def main() -> f24: return distance((10.0, 10.0), (20.0, 20.0)) ``` So far, this does look like Python, doesn't it? What about objects? Well - here, there is a difference. In Python, we have classes. In Bend, we just have the objects themselves. This is how we create a 2D vector: ```python object V2 { x, y } def distance(a: V2, b: V2) -> f24: open V2: a open V2: b dx = b.x - a.x dy = b.y - a.y return (dx * dx + dy * dy) ** 0.5 def main() -> f24: return distance(V2 { x: 10.0, y: 10.0 }, V2 { x: 20.0, y: 20.0 }) ``` This doesn't look too different, does it? What is that `open` thing, though? It just tells Bend to _consume_ the vector, `a`, "splitting" it into its components, `a.x` and `a.y`. Is that really necessary? Actually, no - not really. But, _for now_, it is. This has to do with the fact Bend is an affine language, which... well, let's not get into that. For now, just remember we need `open` to access fields. Bend comes with 3 built-in numeric types: `u24`, `i24`, `f24`. That's quite small, we admit. Soon, we'll have larger types. For now, that's what we got. The `u24` type is written like `123` or `0xF`. The `i24` type requires a sign, as in, `+7` or `-7`. The `f24` type uses `.`, like `3.14`. Other than tuples, Bend has another, very general, way to encode data: datatypes! These are just "objects with tags". A classic example of this is a "shape", which can be either a circle or a rectangle. It is defined like this: ```python type Shape: Circle { radius } Rectangle { width, height } def area(shape: Shape) -> f24: match shape: case Shape/Circle: return 3.14 * shape.radius ** 2.0 case Shape/Rectangle: return shape.width * shape.height def main() -> f24: return area(Shape/Circle { radius: 10.0 }) ``` In this example, `Shape` is a datatype with two variants: `Circle` and `Rectangle`. The `area` function uses pattern matching to handle each variant appropriately. Just like objects need `open`, datatypes need `match`, which give us access to fields in each respective case. Datatypes are very general. From matrices, to JSON, to quadtrees, every type of data can be represented as a datatype (I mean, that's the name!). In fact, lists - which, on Python, are actually stored as arrays - are represented using datatypes on Bend. Specifically, the type: ```python type List: Nil Cons { head, ~tail } ``` Here, the `Nil` variant represents an empty list, and the `Cons` variant represents a concatenation between an element (`head`) and another list (`tail`). That way, the `[1,2,3]` list could be written as: ```python def main() -> List(u24): my_list = List/Cons{head: 1, tail: List/Cons{head: 2, tail: List/Cons{head: 3, tail: List/Nil}}} return my_list ``` Obviously - that's terrible. So, you can write just instead: ```python def main() -> List(u24): my_list = [1, 2, 3] return my_list ``` Which is decent. But while it is written the same as in Python, it is important to understand it is just the `List` datatype, which means we can operate on it using the `match` notation. For example: ```python def main() -> u24: my_list = [1, 2, 3] match my_list: case List/Cons: return my_list.head case List/Nil: return 0 ``` Will return `1`, which is the first element. > **_NOTE:_** Despite creating lists with `[` `]`, the syntax used for accessing values as in `type[key]` is actually related to the `Map` built-in type. We also have a syntax sugar for strings in Bend, which is just a list of `u24` characters (UTF-16 encoded). The `"Hello, world!"` type we've seen used it! > **_NOTE:_** The actual type used for strings is `String`, which has `String/Cons` and `String/Nil` just like `List` does. Bend also has inline functions, which work just like Python: ```python def main() -> u24: mul_2 = lambda x: x * 2 return mul_2(7) ``` Except without the annoying syntax restrictions. You can also shorten it as `λ`, if you can somehow type that. You can also match on native numbers (`u24`) using the `switch` statement: ```python def slow_mul2(n: u24) -> u24: switch n: case 0: return 0 case _: return 2 + slow_mul2(n-1) def main() -> u24: return slow_mul2(7) ``` The `if-else` syntax is a third option to branch, other than `match` and `switch`. It expects a `u24` (`1` for `true` and `0` for `false`): ```python def is_even(n: u24) -> u24: if n % 2 == 0: return 1 else: return 0 def main() -> u24: return is_even(7) ``` _note - some types, like tuples, aren't being pretty-printed correctly after computation. This will be fixed in the future (TM)_ ## The Dreaded Immutability Finally, let's get straight to the fun part: how do we implement parallel algorithms with Bend? Just kidding. Before we get there, let's talk about loops. You might have noticed we have avoided them so far. That wasn't by accident. There is an important aspect on which Bend diverges from Python, and aligns with Haskell: **variables are immutable**. Not "by default". They just **are**. For example, in Bend, we're not allowed to write: ```python def parity(x: u24) -> String: result = "odd" if x % 2 == 0: result = "even" return result ``` ... because that would require mutating the `result` variable. Instead, we should write: ```python def is_even(x: u24) -> String: if x % 2 == 0: return "even" else: return "odd" def main() -> String: return is_even(7) ``` Which is immutable. If that sounds annoying, that's because **it is**. Don't let anyone tell you otherwise. We are aware of that, and we have many ideas on how to improve this, making Bend feel even more Python-like. For now, we have to live with it. But, wait... if variables are immutable... how do we even do loops? For example: ```python def sum(x: u24) -> u24: total = 0 for i in range(10) total += i return total ``` Here, the entire way the algorithm works is by mutating the `total` variable. Without mutability, loops don't make sense. The good news is Bend has _something else_ that is equally as - actually, more - powerful. And learning it is really worth your time. Let's do it! ## Folds and Bends ### Recursive Datatypes Let's start by implementing a recursive datatype in Bend: ```python type Tree: Node { ~left, ~right } Leaf { value } ``` This defines a binary tree, with elements on leaves. Here, `~` flags a field as _recursive_. For example, the tree: ``` __/\__ /\ /\ 1 2 3 4 ``` Could be represented as: ``` tree = Tree/Node{ left: Tree/Node{left: Tree/Leaf {value: 1}, right: Tree/Leaf {value: 2}}, right: Tree/Node{left: Tree/Leaf {value: 3}, right: Tree/Leaf {value: 4}}, } ``` Binary trees are so useful in Bend that this type is already pre-defined in the language and has its own dedicated syntax: ```py # ![a, b] => Equivalent to Tree/Node { left: a, right: b } # !x => Equivalent to Tree/Leaf { value: x } tree = ![![!1, !2],![!3, !4]] ``` ### Fold: consuming recursive datatypes Now, here's a question: how do we _sum_ the elements of a tree? In Python, we could just use a loop. In Bend, we don't have loops. Fortunately, there is another construct we can use: it's called `fold`, and it works like a _search and replace_ for datatypes. For example, consider the code below: ```python def sum(tree: Tree(u24)) -> u24: fold tree: case Tree/Node: return tree.left + tree.right case Tree/Leaf: return tree.value def main() -> u24: tree = ![![!1, !2],![!3, !4]] return sum(tree) ``` It accomplishes the task by replacing every `Tree/Node { left, right }` by `left + right`, and replacing every `Tree/Leaf` by `value`. As a result, the entire "tree of values" is turned into a "tree of additions", and it evaluates as follows: ```python nums = ((1 + 2) + (3 + 4)) nums = (3 + 7) nums = 10 ``` Now, this may look limiting, but it actually isn't. Folds are known for being universal: _any algorithm that can be implemented with a loop, can be implemented with a fold_. So, we can do much more than just compute an "aggregated value". Suppose we wanted, for example, to transform every element into a tuple of `(index,value)`, returning a new tree. Here's how to do it: ```python def enum(tree): idx = 0 fold tree with idx: case Tree/Node: return ![tree.left(idx * 2 + 0), tree.right(idx * 2 + 1)] case Tree/Leaf: return !(idx, tree.value) def main() -> Tree(u24): tree = ![![!1, !2],![!3, !4]] return enum(tree) ``` Compared to the `sum` algorithm, 3 important things changed: 1. We initialize a state, `idx`, as `0`. 2. We pass new states down as `tree.xyz(new_idx)` 3. The base case receives the final state: the element index So, in the end, we'll have computed a copy of the original tree, except that every element has now became a tuple of index and value. Now, please take a moment to think about this fact: **everything can be computed with a fold.** This idea often takes some time to get used to, but, once you do, it is really liberating, and will let you write better algorithms. As an exercise, use `fold` to implement a "reverse" algorithm for lists: ```python def reverse(list: List(T)) -> List(T): # exercise ? def main() -> List(u24): return reverse([1,2,3]) ``` ## Bend: generating recursive datatypes Bending is the opposite of folding. Whatever `fold` consumes, `bend` creates. The idea is that, by defining an _initial state_ and a _halting condition_, we can "grow" a recursive structure, layer by layer, until the condition is met. For example, consider the code below: ```python def main() -> Tree(u24): bend x = 0: when x < 3: tree = ![fork(x + 1), fork(x + 1)] else: tree = !7 return tree ``` The program above will initialize a state (`x = 0`), and then, for as long as `x < 3`, it will "fork" that state in two, creating a `Tree/Node`, and continuing with `x + 1`. When `x >= 3`, it will halt and return a `Tree/Leaf` with `7`. When all is done, the result will be assigned to the `tree` variable: ```python tree = fork(0) tree = ![fork(1), fork(1)] tree = ![![fork(2),fork(2)], ![fork(2),fork(2)]] tree = ![![![fork(3),fork(3)], ![fork(3),fork(3)]], ![![fork(3),fork(3)], ![fork(3),fork(3)]]] tree = ![![![!7, !7], ![!7, !7]], ![![!7, !7], ![!7, !7]]] ``` With some imagination, we can easily see that, by recursively unrolling a state this way, we can generate any structure we'd like. In fact, `bend` is so general we can even use it to emulate a loop. For example, this Python program: ```python sum = 0 idx = 0 while idx < 10: sum = idx + sum idx = idx + 1 ``` Could be emulated in Bend with a "sequential bend": ```python bend idx = 0: when idx < 10: sum = idx + fork(idx + 1) else: sum = 0 ``` Of course, if you do it, Bend's devs will be very disappointed with you. Why? Because everyone is here for one thing. Let's do it! ## Parallel "Hello, World" So, after all this learning, we're now ready to answer the ultimate question: **How do we write parallel algorithms in Bend?** At this point, you might have the idea: by using _folds_ and _bends_, right? Well... actually not! You do not need to use these constructs at all to make it happen. Anything that _can_ be parallelized _will_ be parallelized on Bend. To be more precise, this: ``` f(g(x)) ``` Can NOT be parallelized, because `f` **depends** on the result of `g`. But this: ``` H(f(x), g(y)) ``` Can be parallelized, because `f(x)` and `g(y)` are **independent**. Traditional loops, on the other hands, are inherently sequential. A loop like: ```python sum = 0 for i in range(8): sum += i ``` Is actually just a similar way to write: ```python sum = (0 + (1 + (2 + (3 + (4 + (5 + (6 + 7))))))) ``` Which is _really bad_ for parallelism, because the only way to compute this is by evaluating the expressions one after the other, in order: ```python sum = (0 + (1 + (2 + (3 + (4 + (5 + (6 + 7))))))) sum = (0 + (1 + (2 + (3 + (4 + (5 + 13)))))) sum = (0 + (1 + (2 + (3 + (4 + 18))))) sum = (0 + (1 + (2 + (3 + 22)))) sum = (0 + (1 + (2 + 25))) sum = (0 + (1 + 27)) sum = (0 + 28) sum = 28 ``` There is nothing Bend could do to save this program: sequentialism is an inherent part of its logic. Now, if we had written, instead: ```python sum = (((0 + 1) + (2 + 3)) + ((4 + 5) + (6 + 7))) ``` Then, we'd have a much easier time evaluating that in parallel. Look at it: ```python sum = (((0 + 1) + (2 + 3)) + ((4 + 5) + (6 + 7))) sum = ((1 + 5) + (9 + 13)) sum = (6 + 22) sum = 28 ``` That's so much better that even the _line count_ is shorter! So, how do you write a parallel program in Bend? **Just write algorithms that aren't helplessly sequential.** That's all there is to it. As long as you write programs like that one, then unlike the former one, they will run in parallel. And that's why `bend` and `fold` are core features: they're, essentially, parallelizable loops. For example, to add numbers in parallel, we can write: ```python def main() -> u24: bend d = 0, i = 0: when d < 28: sum = fork(d+1, i*2+0) + fork(d+1, i*2+1) else: sum = i return sum ``` And that's the parallel "Hello, world"! Now, let's finally run it. But first, let's measure its single-core performance. Also, remember that, for now, Bend only supports 24-bit numbers (`u24`), thus, the results will always be in `mod 16777216`. ``` bend run-rs main.bend ``` On my machine (Apple M3 Max), it completes after `147s`, at `65 MIPS` (Million Interactions Per Second - Bend's version of the FLOPS). That's too long. Let's run it in parallel, by using the **C interpreter** instead: ``` bend run main.bend ``` > Note: `run` is an alias to the `run-c` command. And, just like that, the same program now runs in `8.49s`, at `1137 MIPS`. That's **18x faster**! Can we do better? Sure: let's use the **C compiler** now: ``` bend gen-c main.bend >> main.c ``` This command converts your `bend` file into a small, dependency-free C file that does the same computation much faster. You can compile it to an executable: ``` gcc main.c -o main -O2 -lm -lpthread # if you're on Linux gcc main.c -o main -O2 # if you're on OSX ./main ``` Now, the same program runs in `5.81s`, at `1661.91 MIPS`. That's now **25x faster** than the original! Can we do better? Let's now enter the unexplored realms of arbitrary high-level programs on... GPUs. How hard that could be? Well, for us... it was. A lot. For you... just call the **CUDA interpreter**: ``` bend run-cu main.bend ``` And, simply as that, the same program now runs in `0.82s`, at a blistering `11803.24 MIPS`. That's **181x faster** than the original. Congratulations! You're now a thread bender. ~ As a last note, you may have noticed that the compiled version isn't much faster than the interpreted one. Our compiler is still on its infancy, and the assembly generated is quite abysmal. Most of our effort went into setting up a foundation for the parallel evaluator, which was no easy task. With that out of our way, improving the compiler is a higher priority now. You can expect it to improve continuously over time. For now, it is important to understand the state of things, and set up reasonable expectations. ## A Parallel Bitonic Sort The bitonic sort is a popular algorithm that sorts a set of numbers by moving them through a "circuit" (sorting network) and swapping as they pass through: ![bitonic-sort](https://upload.wikimedia.org/wikipedia/commons/thumb/b/bd/BitonicSort1.svg/1686px-BitonicSort1.svg.png) In CUDA, this can be implemented by using mutable arrays and synchronization primitives. This is well known. What is less known is that it can also be implemented as a series of _immutable tree rotations_, with pattern-matching and recursion. Don't bother trying to understand it, but, here's the code: ```python def gen(d: u24, x: u24) -> Any: switch d: case 0: return x case _: return (gen(d-1, x * 2 + 1), gen(d-1, x * 2)) ``` > Note: The type of this function can't be expressed with Bend's type system, but we can still write it using `Any`. ```python def sum(d: u24, t: u24) -> u24: switch d: case 0: return t case _: (t.a, t.b) = t return sum(d-1, t.a) + sum(d-1, t.b) def swap(s: u24, a: Any, b: Any) -> (Any, Any): switch s: case 0: return (a,b) case _: return (b,a) def warp(d: u24, s: u24, a: Any, b: Any) -> (Any, Any): switch d: case 0: return swap(s ^ (a > b), a, b) case _: (a.a,a.b) = a (b.a,b.b) = b (A.a,A.b) = warp(d-1, s, a.a, b.a) (B.a,B.b) = warp(d-1, s, a.b, b.b) return ((A.a,B.a),(A.b,B.b)) def flow(d: u24, s: u24, t: Any) -> Any: switch d: case 0: return t case _: (t.a, t.b) = t return down(d, s, warp(d-1, s, t.a, t.b)) def down(d: u24, s: u24, t: Any) -> Any: switch d: case 0: return t case _: (t.a, t.b) = t return (flow(d-1, s, t.a), flow(d-1, s, t.b)) def sort(d: u24, s: u24, t: Any) -> Any: switch d: case 0: return t case _: (t.a, t.b) = t return flow(d, s, (sort(d-1, 0, t.a), sort(d-1, 1, t.b))) def main() -> u24: return sum(18, sort(18, 0, gen(18, 0))) ``` As a test of Bend's ability to parallelize the most insanely high-level computations possible, let's benchmark this program. Here are the results: - 12.33s / 102 MIPS (Apple M3 Max, 1 thread) - 0.96s / 1315 MIPS (Apple M3 Max, 16 threads) - 12x speedup - 0.24s / 5334 MIPS (NVIDIA RTX 4090, 16k threads) - 51x speedup And, just like magic, it works! 51x faster on RTX. How cool is that? Of course, you would absolutely **not** want to sort numbers like that, specially when mutable arrays exist. But there are many algorithms that _can not_ be implemented easily with buffers. Evolutionary and genetic algorithms, proof checkers, compilers, interpreters. For the first time ever, you can implement these algorithms as high-level functions, in a language that runs on GPUs. That's the magic of Bend! ## Graphics Rendering While the algorithm above does parallelize well, it is very memory-hungry. It is a nice demo of Bend's potential, but isn't a great way to sort lists. Currently, Bend has a 4GB memory limit (for being a 32-bit architecture). When the memory is filled, its performance will degrade considerably. But we can do better. Since Bend is GC-free, we can express low memory footprint programs using `bend` or tail calls. For maximum possible performance, one should first create enough "parallel room" to fill all available cores, and then spend some time doing compute-heavy, but less memory-hungry, computations. For example, consider: ```python # given a shader, returns a square image def render(depth: u24) -> Any: bend d = 0, i = 0: when d < depth: color = (fork(d+1, i*2+0), fork(d+1, i*2+1)) else: width = depth / 2 color = demo_shader(i % width, i / width) return color # given a position, returns a color # for this demo, it just busy loops def demo_shader(x: Any, y: Any) -> Any: bend i = 0: when i < 100000: color = fork(i + 1) else: color = 0x000001 return color # renders a 256x256 image using demo_shader def main() -> Any: return render(16, demo_shader) ``` It emulates an OpenGL fragment shader by building an "image" as a perfect binary tree, and then calling the `demo_shader` function on each pixel. Since the tree has a depth of 16, we have `2^16 = 65536 pixels`, which is enough to fill all cores of an RTX 4090. Moreover, since `demo_shader` isn't doing many allocations, it can operate entirely inside the GPU's "shared memory" (L1 cache). Each GPU thread has a local space of 64 IC nodes. Functions that don't need more than that, like `demo_shader`, can run up to 5x faster! On my GPU, it performs `22,000 MIPS` out of the box, and `40000+ MIPS` with a tweak on the generated CUDA file (doubling the `TPC`, which doubles the number of threads per block). In the near future, we plan to add immutable textures, allowing for single-interaction sampling. With some napkin math, this should be enough to render 3D games in real-time. Imagine a future where game engines are written in Python-like languages? That's the future we're building, with Bend! You can see your programs total cost (number of interactions) and performance (MIPS) by adding the `-s` flag. This is a good way to check if your algorithm is parallelizing. For example, on my Apple M3 Max, sequential algorithms will perform about 100 MIPS on interpreted mode, and 130 MIPS on compiled mode (remember our compiler is still **very** immature, which is why it isn't much faster than the interpreter). A well-parallelizable program, though, will easily reach 1000+ MIPS. ## To be continued... This guide isn't extensive, and there's a lot uncovered. For example, Bend also has an entire Haskell-like functional syntax that is compatible with old HVM1, you can find it documented [here](https://github.com/HigherOrderCO/Bend/blob/main/docs/syntax.md#fun-syntax). You can also check [this](https://gist.github.com/VictorTaelin/9cbb43e2b1f39006bae01238f99ff224) out, it's an implementation of the Bitonic Sort with Haskell-like equations. ## Community Remember: Bend is very new and experimental. Bugs and imperfections should be expected. That said, [HOC](https://HigherOrderCO.com/) will provide long-term support to Bend (and its runtime, HVM2). So, if you believe this paradigm will be big someday, and want to be part of it in these early stages, join us on [Discord](https://Discord.HigherOrderCO.com/). Report bugs, bring your suggestions, and let's chat and build this future together! ================================================ FILE: LICENSE-APACHE ================================================ Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS Copyright 2023-2024 Higher Order Company Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ================================================ FILE: README.md ================================================

Bend

A high-level, massively parallel programming language

## Index 1. [Introduction](#introduction) 2. [Important Notes](#important-notes) 3. [Install](#install) 4. [Getting Started](#getting-started) 5. [Speedup Example](#speedup-examples) 6. [Additional Resources](#additional-resources) ## Introduction Bend offers the feel and features of expressive languages like Python and Haskell. This includes fast object allocations, full support for higher-order functions with closures, unrestricted recursion, and even continuations. Bend scales like CUDA, it runs on massively parallel hardware like GPUs, with nearly linear acceleration based on core count, and without explicit parallelism annotations: no thread creation, locks, mutexes, or atomics. Bend is powered by the [HVM2](https://github.com/higherorderco/hvm) runtime. ## Important Notes * Bend is designed to excel in scaling performance with cores, supporting over 10000 concurrent threads. * The current version may have lower single-core performance. * You can expect substantial improvements in performance as we advance our code generation and optimization techniques. * We are still working to support Windows. Use [WSL2](https://learn.microsoft.com/en-us/windows/wsl/install) as an alternative solution. * [We only support NVIDIA Gpus currently](https://github.com/HigherOrderCO/Bend/issues/341). ## Install ### Install dependencies #### On Linux ```sh # Install Rust if you haven't already. curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # For the C version of Bend, use GCC. We recommend a version up to 12.x. sudo apt install gcc ``` For the CUDA runtime [install the CUDA toolkit for Linux](https://developer.nvidia.com/cuda-downloads?target_os=Linux) version 12.x. #### On Mac ```sh # Install Rust if you haven't it already. curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # For the C version of Bend, use GCC. We recommend a version up to 12.x. brew install gcc ``` ### Install Bend 1. Install HVM2 by running: ```sh # HVM2 is HOC's massively parallel Interaction Combinator evaluator. cargo install hvm # This ensures HVM is correctly installed and accessible. hvm --version ``` 2. Install Bend by running: ```sh # This command will install Bend cargo install bend-lang # This ensures Bend is correctly installed and accessible. bend --version ``` ### Getting Started #### Running Bend Programs ```sh bend run # uses the C interpreter by default (parallel) bend run-rs # uses the Rust interpreter (sequential) bend run-c # uses the C interpreter (parallel) bend run-cu # uses the CUDA interpreter (massively parallel) # Notes # You can also compile Bend to standalone C/CUDA files using gen-c and gen-cu for maximum performance. # The code generator is still in its early stages and not as mature as compilers like GCC and GHC. # You can use the -s flag to have more information on # Reductions # Time the code took to run # Interaction per second (In millions) ``` #### Testing Bend Programs The example below sums all the numbers in the range from `start` to `target`. It can be written in two different methods: one that is inherently sequential (and thus cannot be parallelized), and another that is easily parallelizable. (We will be using the `-s`flag in most examples, for the sake of visibility) #### Sequential version: First, create a file named `sequential_sum.bend` ```sh # Write this command on your terminal touch sequential_sum.bend ``` Then with your text editor, open the file `sequential_sum.bend`, copy the code below and paste in the file. ```py # Defines the function Sum with two parameters: start and target def Sum(start, target): if start == target: # If the value of start is the same as target, returns start. return start else: # If start is not equal to target, recursively call Sum with # start incremented by 1, and add the result to start. return start + Sum(start + 1, target) def main(): # This translates to (1 + (2 + (3 + (...... + (999999 + 1000000))))) # Note that this will overflow the maximum value of a number in Bend return Sum(1, 1_000_000) ``` ##### Running the file You can run it using Rust interpreter (Sequential) ```sh bend run-rs sequential_sum.bend -s ``` Or you can run it using C interpreter (Sequential) ```sh bend run-c sequential_sum.bend -s ``` If you have a NVIDIA GPU, you can also run in CUDA (Sequential) ```sh bend run-cu sequential_sum.bend -s ``` In this version, the next value to be calculated depends on the previous sum, meaning that it cannot proceed until the current computation is complete. Now, let's look at the easily parallelizable version. #### Parallelizable version: First close the old file and then proceed to your terminal to create `parallel_sum.bend` ```sh # Write this command on your terminal touch parallel_sum.bend ``` Then with your text editor, open the file `parallel_sum.bend`, copy the code below and paste in the file. ```py # Defines the function Sum with two parameters: start and target def Sum(start, target): if start == target: # If the value of start is the same as target, returns start. return start else: # If start is not equal to target, calculate the midpoint (half), # then recursively call Sum on both halves. half = (start + target) / 2 left = Sum(start, half) # (Start -> Half) right = Sum(half + 1, target) return left + right # A parallelizable sum of numbers from 1 to 1000000 def main(): # This translates to (((1 + 2) + (3 + 4)) + ... (999999 + 1000000)...) return Sum(1, 1_000_000) ``` In this example, the (3 + 4) sum does not depend on the (1 + 2), meaning that it can run in parallel because both computations can happen at the same time. ##### Running the file You can run it using Rust interpreter (Sequential) ```sh bend run-rs parallel_sum.bend -s ``` Or you can run it using C interpreter (Parallel) ```sh bend run-c parallel_sum.bend -s ``` If you have a NVIDIA GPU, you can also run in CUDA (Massively parallel) ```sh bend run-cu parallel_sum.bend -s ``` In Bend, it can be parallelized by just changing the run command. If your code **can** run in parallel it **will** run in parallel. ### Speedup Examples The code snippet below implements a [bitonic sorter](https://en.wikipedia.org/wiki/Bitonic_sorter) with *immutable tree rotations*. It's not the type of algorithm you would expect to run fast on GPUs. However, since it uses a divide and conquer approach, which is inherently parallel, Bend will execute it on multiple threads, no thread creation, no explicit lock management. #### Bitonic Sorter Benchmark - `bend run-rs`: CPU, Apple M3 Max: 12.15 seconds - `bend run-c`: CPU, Apple M3 Max: 0.96 seconds - `bend run-cu`: GPU, NVIDIA RTX 4090: 0.21 seconds
Click here for the Bitonic Sorter code ```py # Sorting Network = just rotate trees! def sort(d, s, tree): switch d: case 0: return tree case _: (x,y) = tree lft = sort(d-1, 0, x) rgt = sort(d-1, 1, y) return rots(d, s, (lft, rgt)) # Rotates sub-trees (Blue/Green Box) def rots(d, s, tree): switch d: case 0: return tree case _: (x,y) = tree return down(d, s, warp(d-1, s, x, y)) # Swaps distant values (Red Box) def warp(d, s, a, b): switch d: case 0: return swap(s ^ (a > b), a, b) case _: (a.a, a.b) = a (b.a, b.b) = b (A.a, A.b) = warp(d-1, s, a.a, b.a) (B.a, B.b) = warp(d-1, s, a.b, b.b) return ((A.a,B.a),(A.b,B.b)) # Propagates downwards def down(d,s,t): switch d: case 0: return t case _: (t.a, t.b) = t return (rots(d-1, s, t.a), rots(d-1, s, t.b)) # Swaps a single pair def swap(s, a, b): switch s: case 0: return (a,b) case _: return (b,a) # Testing # ------- # Generates a big tree def gen(d, x): switch d: case 0: return x case _: return (gen(d-1, x * 2 + 1), gen(d-1, x * 2)) # Sums a big tree def sum(d, t): switch d: case 0: return t case _: (t.a, t.b) = t return sum(d-1, t.a) + sum(d-1, t.b) # Sorts a big tree def main: return sum(20, sort(20, 0, gen(20, 0))) ```
if you are interested in some other algorithms, you can check our [examples folder](https://github.com/HigherOrderCO/Bend/tree/main/examples) ### Additional Resources - To understand the technology behind Bend, check out the HVM2 [paper](https://paper.higherorderco.com/). - We are working on an official documentation, meanwhile for a more in depth explanation check [GUIDE.md](https://github.com/HigherOrderCO/Bend/blob/main/GUIDE.md) - Read about our features at [FEATURES.md](https://github.com/HigherOrderCO/Bend/blob/main/FEATURES.md) - Bend is developed by [HigherOrderCO](https://higherorderco.com/) - join our [Discord](https://discord.higherorderco.com)! ================================================ FILE: cspell.json ================================================ { "version": "0.2", "language": "en", "words": [ "anni", "annihilations", "arities", "arity", "arrayvec", "behaviour", "bitand", "Bitonic", "builtins", "callcc", "chumsky", "clippy", "codegen", "codepoint", "codepoints", "combinators", "concat", "ctrs", "cuda", "datatypes", "Deque", "destructures", "desugared", "desugars", "devs", "dups", "effectful", "elif", "elifs", "foldl", "hasher", "hexdigit", "Hindley", "hvm's", "indexmap", "inet", "inets", "inlineable", "inlineables", "inlinees", "inlines", "inodes", "insta", "interner", "ints", "itertools", "ITRS", "kwarg", "kwargs", "lcons", "linearization", "linearizes", "linearizing", "lnil", "lpthread", "mant", "Milner", "miscompilation", "mult", "namegen", "nams", "nanosleep", "nats", "newtype", "nilary", "nullary", "numop", "nums", "OOM's", "oper", "opers", "parallelizable", "peekable", "postcondition", "powi", "prec", "proto", "Pythonish", "quadtree", "quadtrees", "rbag", "readback", "recursively", "redex", "redexes", "repr", "resugar", "resugared", "resugaring", "rfold", "rsplit", "rwts", "scons", "scopeless", "scrutinee", "sequentialism", "snil", "SOTA", "stdext", "struct", "subcmd", "submatch", "subpattern", "subpatterns", "subterm", "subterms", "succ", "supercombinator", "supercombinators", "Tarjan's", "tlsv", "TSPL", "tunr", "unbounds", "undefer", "vectorize", "vectorizes", "walkdir" ], "files": [ "**/*.rs", "**/*.md" ], "ignoreRegExpList": [ "HexValues", "/λ/g", "/-O/g", "/`.`/g", "/`..`/g", "/`...`/g", "/`....`/g", "/`.....`/g", "/```(.*\n)*```/g" ] } ================================================ FILE: docs/builtins.md ================================================ > this is a WIP based on [Builtins.bend](https://github.com/HigherOrderCO/Bend/blob/main/src/fun/builtins.bend). # Built-in Types and Functions **Bend** built-in types and functions, this document serves as a reference guide. Read more at [FEATURES.md](https://github.com/HigherOrderCO/Bend/blob/main/FEATURES.md). ## String ```python type String: Nil Cons { head: u24, ~tail: String } ``` - **Nil**: Represents an empty string. - **Cons head ~tail**: Represents a string with a `head` character and a `tail` string. ### Syntax A String literal is surrounded with `"`. Accepts the same values as characters literals. ``` "Hello, World!" ``` ### Functions #### String/equals ```python #{ Checks if two strings are equal. #} def String/equals (s1: String) (s2: String) : u24 ``` #### String/split ```python #{ Splits a string into a list of strings based on the given delimiter. #} String/split (s: String) (delimiter: u24) : (List String) ``` ## List ```python type List(T): Nil Cons { head: T, ~tail: List(T) } ``` - **Nil**: Represents an empty list. - **Cons head ~tail**: Represents a list with a `head` element and a `tail` list. - **T**: Represents the type of the elements in the list. ### Syntax A List of values can be written using `[ ]`, it can have multiple values inside, using `,` you can divide its value in a list of multiple elements. ``` ["This", "List", "Has", "Multiple", "Values"] ``` ### Functions #### List/length ```python #{ Returns a tuple containing the length and the list itself. #} def List/length(xs: List(T)) -> (u24, List(T)): ``` #### List/reverse ```python #{ Reverses the elements of a list. #} def List/reverse(xs: List(T)) -> List(T): ``` #### List/flatten ```python #{ Returns a flattened list from a list of lists. #} List/flatten (xs: (List (List T))) : (List T) ``` Example: ```python List/flatten([[1], [2, 3], [4]]) # Result: [1, 2, 3, 4] ``` #### List/concat ```python #{ Appends two lists together. #} def List/concat(xs: (List T)) (ys: (List T)) : (List T) ``` Example: ```python List/concat([1, 2], [4, 5]) # Result: [1, 2, 4, 5] ``` #### List/filter ```python #{ Filters a list based on a predicate function. #} List/filter(xs: List(T), pred: T -> Bool) -> List(T) ``` #### List/split_once ```python #{ Splits a list into two lists at the first occurrence of a value. #} def List/split_once(xs: List(T), cond: T -> u24) -> (Result((List(T), List(T)), List(T))): ``` Example: ```python # Split list at first even number list = [1,3,4,5,6] result = List/split_once(list, λx: x % 2 == 0) return result # Result: Result/Ok/tag ([1, 3], [5, 6]) ``` ## Result ```python type (Result o e) = (Ok (val: o)) | (Err (val: e)) ``` ### Result/unwrap Returns the inner value of `Result/Ok` or `Result/Err`. If the types `A` and `B` are different, should only be used in type unsafe programs or when only one variant is guaranteed to happen. ```python #{ Returns the inner value of `Result/Ok` or `Result/Err`. If the types `A` and `B` are different, should only be used in type unsafe programs or when only one variant is guaranteed to happen. #} def Result/unwrap(res: Result(T, E)) -> Any: ``` ## Tree ```python type Tree(T): Node { ~left: Tree(T), ~right: Tree(T) } Leaf { value: T } ``` **`Tree`** represents a tree with values stored in the leaves. Trees are a structure that naturally lends itself to parallel recursion, so writing your problem in terms of trees is a good first approach to parallelize your code. - **Node { ~left ~right }**: Represents a tree node with `left` and `right` subtrees. - **Leaf { value }**: Represents one of the ends of the tree, storing `value`. - **T**: Represents the type of the elements in the tree. #### Syntax **Bend** provides the `![]` operator to create tree branches and the `!` operator to create a tree leaf. ```py # ![a, b] => Equivalent to Tree/Node { left: a, right: b } # !x => Equivalent to Tree/Leaf { value: x } tree = ![![!1, !2],![!3, !4]] ``` Technically your trees don't need to end with leaves, but if you don't, your program will be very hard to reason about. ## Maybe ```python type Maybe(T): Some{ value } None ``` **`Maybe`** is a structure that may or not contain a value. It is meant to be used as a return type for functions that can fail. This way you don't need to resort to unreachable() in order to handle errors. #### Syntax Here's how you create a new `Maybe` containing the Nat value of 1: ```python maybe = Maybe/Some(Nat/Succ(Nat/Zero)) ``` ## Maybe functions ### Maybe/unwrap ```python #{ Returns the value inside the `Maybe` if it is `Some`, and returns `unreachable()` if it is `None`. #} def Maybe/unwrap(m: Maybe(T)) -> T ``` ## Map ```python type Map(T): Node { value: Maybe(T), ~left: Map(T), ~right: Map(T) } Leaf ``` **`Map`** represents a tree with values stored in the branches. It is meant to be used as an efficient map data structure with integer keys and O(log n) read and write operations. - **Node { value: Maybe(T), ~left: Map(T), ~right: Map(T) }**: Represents a map node with a `Maybe` and `left` and `right` subtrees. Empty nodes have `Maybe/None` stored in the `value` field, whilst non-empty nodes have `Maybe/Some` stored in the `value` field. - **Leaf**: Represents an unwritten, empty portion of the map. #### Syntax Here's how you create a new `Map` with some initial values.: ```python def main(): return { 0: 4, `hi`: "bye", 'c': 2 + 3 } ``` The keys must be `U24` numbers, and can be given as literals or any other expression that evaluates to a `U24`. As long as your function isn't typed, like the one in the example, the values can be anything. But storing data of different types in a `Map` will make it harder for you to reason about it. You can read and write a value of a map with the `[]` operator: ```python map = { 0: "zero", 1: "one", 2: "two", 3: "three" } map[0] = "not zero" map[1] = 2 map[2] = 3 map[3] = map[1] + map[map[1]] ``` Here, `map` must be the name of the `Map` variable, and the keys inside `[]` can be any expression that evaluates to a `U24`. ## Map functions ### Map/empty ```python #{ Initializes an empty map. #} def Map/empty() -> Map(T) ``` ### Map/get ```rust #{ Retrieves a `value` from the `map` based on the `key` and returns a tuple with the value and the `map` unchanged. The logic for checking whether a value is or not contained in a `map` is not done in the `get` function, so if we try to get a key that is not in the map, the program will return `unreachable`. #} def Map/get (map: Map(T), key: u24) -> (T, Map(T)) ``` #### Syntax Considering the following map ```python { 0: "hello", 1: "bye", 2: "maybe", 3: "yes"} ``` The `get` function can be written as ``` return x[0] # Gets the value of the key 0 ``` And the value resultant from the get function would be: ``` "hello" ``` ### Map/set ```rust #{ Sets a value on a Map, returning the map with the value mapped. #} def Map/set (map: Map(T), key: u24, value: T) -> Map(T) ``` #### Syntax Considering the following tree ```python { 0: "hello", 1: "bye", 2: "maybe", 3: "yes"} ``` The `set` function can be written as ```py x[0] = "swapped" # Assigns the key 0 to the value "swapped" ``` And the value resultant from the get function would be: ```py { 0: "swapped", 1: "bye", 2: "maybe", 3: "yes"} ``` If there's no matching `key` in the tree, it would add a new branch to that tree with the value `set` ```py x[4] = "added" # Assigns the key 4 to the value "added" ``` The new tree ```py { 0: "swapped", 1: "bye", 2: "maybe", 3: "yes", 4: "added"} ``` ### Map/map ```rust #{ Applies a function to a value in the map and returns the map with the value mapped. #} def Map/map (map: Map(T), key: u24, f: T -> T) -> Map(T) ``` #### Syntax With the same map that we `set` in the previous section, we can map it's values with `@=`: ```py x[0] @= lambda y: String/concat(y, " and mapped") # x[0] now contains "swapped and mapped" ``` ### Map/contains ```python #{ Checks if a `map` contains a given `key` and returns 0 or 1 along with and `map` unchanged. #} def Map/contains (map: Map(T), key: u24) -> (u24, Map(T)) #### Syntax With the same map that we `set` in the previous section, we can call the function `Map/contains` explicitly: ```python (num, map) = Map/contains(m, key) return num ``` Whilst the `num` variable will contain 0 or 1 depending on if the key is in the map or not. ## Nat ```python type Nat = (Succ ~(pred: Nat)) | (Zero) ``` - **Succ ~pred**: Represents a natural number successor. - **Zero**: Represents the natural number zero. ## DiffList DiffList is a list that has constant time prepends (cons), appends and concatenation, but can't be pattern matched. It is implemented as a function that receives a list to be appended to the last element of the DiffList. For example, the list `List/Cons(1, List/Cons(2, List/Nil))` can be written as the difference list `lambda x: List/Cons(1, List/Cons(2, x))`. ### Functions #### DiffList/new ```python #{ Creates a new difference list. #} def DiffList/new() -> (List(T) -> List(T)) ``` #### DiffList/append ```python #{ Appends a value to the end of the difference list. #} def DiffList/append(diff: List(T) -> List(T), val: T) -> (List(T) -> List(T)) ``` #### DiffList/cons ```python #{ Appends a value to the beginning of the difference list. #} def DiffList/cons(diff: List(T) -> List(T), val: T) -> (List(T) -> List(T)) ``` #### DiffList/to_list ```python #{ Converts a difference list to a regular cons list. #} def DiffList/to_list(diff: List(T) -> List(T)) -> (List(T)) ``` ## IO The basic builtin IO functions are under development and will be stable in the next milestone. Here is the current list of functions, but be aware that they may change in the near future. ### Printing ```python #{ Prints the string `text` to the standard output, encoded with utf-8. #} def IO/print(text: String) -> IO(None) ``` ### Input ```python #{ Reads characters from the standard input until a newline is found. Returns the read input as a String decoded with utf-8. #} def IO/input() -> IO(Result(String, u24)) ``` ### File IO #### File open ```python #{ Opens a file with with `path` being given as a string and `mode` being a string with the mode to open the file in. The mode should be one of the following: #} def IO/FS/open(path: String, mode: String) -> IO(Result(u24, u24)) ``` - `"r"`: Read mode - `"w"`: Write mode (write at the beginning of the file, overwriting any existing content) - `"a"`: Append mode (write at the end of the file) - `"r+"`: Read and write mode - `"w+"`: Read and write mode - `"a+"`: Read and append mode Returns an U24 with the file descriptor. File descriptors are not necessarily the same as the ones assigned by the operating system, but rather unique identifiers internal to Bend's runtime. #### File descriptors for standard files The standard input/output files are always open and assigned the following file descriptors: - `IO/FS/STDIN = 0`: Standard input - `IO/FS/STDOUT = 1`: Standard output - `IO/FS/STDERR = 2`: Standard error #### File close ```python #{ Closes the file with the given `file` descriptor. #} def IO/FS/close(file: u24) -> IO(Result(None, u24)) ``` #### File read ```python #{ Reads `num_bytes` bytes from the file with the given `file` descriptor. Returns a list of U24 with each element representing a byte read from the file. #} def IO/FS/read(file: u24, num_bytes: u24) -> IO(Result(List(u24), u24)) ``` ```python #{ Reads a line from the file with the given `file` descriptor. Returns a list of U24 with each element representing a byte read from the file. #} def IO/FS/read_line(fd: u24) -> IO(Result(List(u24), u24)) ``` ```python #{ Reads until the end of the file with the given `file` descriptor. Returns a list of U24 with each element representing a byte read from the file. #} def IO/FS/read_to_end(fd: u24) -> IO(Result(List(u24), u24)) ``` ```python #{ Reads an entire file with the given `path` and returns a list of U24 with each element representing a byte read from the file. #} def IO/FS/read_file(path: String) -> IO(Result(List(u24), u24)) ``` #### File write ```python #{ Writes `bytes`, a list of U24 with each element representing a byte, to the file with the given `file` descriptor. Returns nothing (`*`). #} def IO/FS/write(file: u24, bytes: List(u24)) -> IO(Result(None, u24)) ``` ```python #{ Writes `bytes`, a list of U24 with each element representing a byte, as the entire content of the file with the given `path`. #} def IO/FS/write_file(path: String, bytes: List(u24)) -> IO(Result(None, u24)) ``` #### File seek ```python #{ Moves the current position of the file with the given `file` descriptor to the given `offset`, an I24 or U24 number, in bytes. #} def IO/FS/seek(file: u24, offset: i24, mode: i24) -> IO(Result(None, u24)) ``` `mode` can be one of the following: - `IO/FS/SEEK_SET = 0`: Seek from start of file - `IO/FS/SEEK_CUR = 1`: Seek from current position - `IO/FS/SEEK_END = 2`: Seek from end of file Returns nothing (`*`). #### File flush ```python #{ Flushes the file with the given `file` descriptor. Returns nothing (`*`). #} def IO/FS/flush(file: u24) -> IO(Result(None, u24)) ``` ### Dinamically linked libraries It's possible to dynamically load shared objects (libraries) with functions that implement the Bend IO interface. You can read more on how to implement these libraries in the [Dynamically linked libraries and foreign functions](docs/ffi.md) documentation. #### IO/DyLib/open ```py #{ Loads a dynamic library file. #} def IO/DyLib/open(path: String, lazy: u24) -> IO(Result(u24, String)) ``` - `path` is the path to the library file. - `lazy` is a boolean encoded as a `u24` that determines if all functions are loaded lazily (`1`) or upfront (`0`). - Returns an unique id to the library object encoded as a `u24`. #### IO/DyLib/call ```py #{ Calls a function of a previously opened library. - `dl` is the id of the library object. - `fn` is the name of the function in the library. - `args` are the arguments to the function. The expected values depend on the called function. - The returned value is determined by the called function. #} def IO/DyLib/call(dl: u24, fn: String, args: Any) -> IO(Result(Any, String)) ``` #### IO/DyLib/close ```py #{ Closes a previously open library. - `dl` is the id of the library object. - Returns nothing (`*`). #} def IO/DyLib/close(dl: u24) -> IO(Result(None, String)) ``` ## Native number casting ### to_f24 ```py #{ Casts an u24 number to an f24. #} def u24/to_f24 -> (u24 -> f24) #{ Casts an i24 number to an f24. #} def i24/to_f24 -> (i24 -> f24) ``` ### to_u24 ```py #{ Casts a f24 number to an u24. #} def f24/to_u24 -> (f24 -> u24) #{ Casts an i24 number to an u24. #} def i24/to_u24 -> (i24 -> u24) ``` ### to_i24 ```py #{ Casts an u24 number to an i24. #} def u24/to_i24 -> (u24 -> i24): #{ Casts a f24 number to an i24. #} def f24/to_i24 -> (f24 -> i24): ``` ### to_string ```py #{ Casts an u24 native number to a string. #} def u24/to_string(n: u24) -> String: ``` ## String encoding / decoding ### String/decode_utf8 ```py #{ Decodes a sequence of bytes to a String using utf-8 encoding. #} String/decode_utf8 (bytes: (List u24)) : String ``` ### String/decode_ascii ```py #{ Decodes a sequence of bytes to a String using ascii encoding. #} String/decode_ascii (bytes: (List u24)) : String ``` ### String/encode_utf8 ```py #{ Encodes a String to a sequence of bytes using utf-8 encoding. #} String/encode_utf8 (str: String) : (List u24) ``` ### String/encode_ascii ```py #{ Encodes a String to a sequence of bytes using ascii encoding. #} String/encode_ascii (str: String) : (List u24) ``` ### Utf8/decode_character ```py #{ Decodes a utf-8 character, returns a tuple containing the rune and the rest of the byte sequence. #} Utf8/decode_character (bytes: (List u24)) : (u24, (List u24)) ``` ### Utf8/REPLACEMENT_CHARACTER ```py Utf8/REPLACEMENT_CHARACTER : u24 = '\u{FFFD}' ``` ## Math ### Math/log ```py #{ Computes the logarithm of `x` with the specified `base`. #} def Math/log -> (f24 -> f24 -> f24) ``` ### Math/atan2 ```py #{ Computes the arctangent of `y / x`. Has the same behaviour as `atan2f` in the C math lib. #} def Math/atan2 -> (f24 -> f24 -> f24) ``` ### Math/PI ```py #{ Defines the Pi constant. #} def Math/PI() -> f24 ``` ### Math/E ```py #{ Euler's number #} def Math/E() -> f24 ``` ### Math/sin ```py #{ Computes the sine of the given angle in radians. #} def Math/sin -> (f24 -> f24) ``` ### Math/cos ```py #{ Computes the cosine of the given angle in radians. #} def Math/cos -> (f24 -> f24) ``` ### Math/tan ```py #{ Computes the tangent of the given angle in radians. #} def Math/tan -> (f24 -> f24) ``` ### Math/cot ```py #{ Computes the cotangent of the given angle in radians. #} Math/cot (a: f24) : f24 ``` ### Math/sec ```py #{ Computes the secant of the given angle in radians. #} Math/sec (a: f24) : f24 ``` ### Math/csc ```py #{ Computes the cosecant of the given angle in radians. #} Math/csc (a: f24) : f24 ``` ### Math/atan ```py #{ Computes the arctangent of the given angle. #} Math/atan (a: f24) : f24 ``` ### Math/asin ```py #{ Computes the arcsine of the given angle. #} Math/asin (a: f24) : f24 ``` ### Math/acos ```py #{ Computes the arccosine of the given angle. #} Math/acos (a: f24) : f24 ### Math/radians ```py #{ Converts degrees to radians. #} Math/radians (a: f24) : f24 ``` ### Math/sqrt ```py #{ Computes the square root of the given number. #} Math/sqrt (n: f24) : f24 ``` ### Math/ceil ```py #{ Round float up to the nearest integer. #} def Math/ceil(n: f24) -> f24 ``` ### Math/floor ```py #{ Round float down to the nearest integer. #} def Math/floor(n: f24) -> f24 ``` ### Math/round ```py #{ Round float to the nearest integer. #} def Math/round(n: f24) -> f24 ``` ## Lazy thunks You can force a function call to be evaluated lazily by wrapping it in a lazy thunk. In Bend, this can be expressed as `lambda x: x(my_function, arg1, arg2, ...)`. To evaluate the thunk, you can use the `undefer` function or apply `lambda x: x` to it. ================================================ FILE: docs/cli-arguments.md ================================================ # CLI arguments It's possible to pass arguments to a program executed with `bend run`: ```sh bend run [Arguments in expression form]... ``` It accepts any expression that would also be valid inside a bend function. Arguments are passed to programs by applying them to the entry point function: ```py # Imp syntax def main(x1, x2, x3): return MainBody(x1 x2 x3) # Calling with `bend run arg1 arg2 arg3 argN`, it becomes (in the "fun" syntax): main = (λx1 λx2 λx3 (MainBody x1 x2 x3) arg1 arg2 arg3 argN) ``` There are no restrictions on the number of arguments passed to the program. You can even pass more arguments than the function expects, although that can lead to unexpected results. ```py # Expects 2 CLI arguments def main(x, y): return {x - y, y - x} ``` ```sh # Calling with just one argument > bend run +5 λa {(- a 5) (- a +5)} # Calling with two argument > bend run +5 +3 {+2 -2} # Calling with three arguments # In this case, the third argument doesn't change anything # due to the underlying interaction rules. # If this were a variant of simply-typed lambda-calculus # it wouldn't be well-typed. > bend run +5 +3 +1 {+2 -2} ``` ================================================ FILE: docs/compilation-and-readback.md ================================================ # Compilation and readback How are terms compiled to interaction net nodes? HVM has a bunch of useful nodes to write IC programs. Every node contains one `main` port `0` and two `auxiliary` ports, `1` and `2`. There are 7 kinds of nodes, Eraser, Constructor, Duplicator, Reference, Number, Operation and Match. A lambda `λx x` compiles into a Constructor node. An application `((λx x) (λx x))` also compiles into a Constructor node. ``` 0 - Points to the lambda occurrence 0 - Points to the function | | λ Lambda @ Application / \ / \ 1 2 - Points to the lambda body 1 2 - Points to the application occurrence | | Points to the lambda variable Points to the argument ``` When reading back, if we visit a Constructor via port 0 then we know it's a lambda, and if we visit it via port 2 it's an application. - The `Number` node uses the label to store it's number. - An `Operation` node uses the label to store it's operation. A duplication `let {a b} = x` compiles into a Duplicator node. A superposition `{a b}` compiles to a Duplicator node too. The difference here comes from context too. ``` 0 - Points to the sup occurrence 0 - Points to the duplicated value | | # Superposition # Duplication / \ / \ 1 2 - Points to the second value 1 2 - Points to the second binding | | Points to the first value Points to the first binding ``` Bend core terms directly compile to HVM nodes. - Application -> CON node with --+ polarization. - Lambda -> CON node with ++- polarization. - Duplication -> DUP node with -++ polarization. - Superposition -> DUP node with +-- polarization - Pairs -> CON node with +-- polarization. - Pair elimination -> CON node with -++ polarization. - Erasure values (as in λx *) -> ERA node with + polarization. - Erased variables (as in λ* x) -> ERA node with + polarization. - Numbers -> NUM node (always + polarization). - Switches -> MAT node (--+) + CON node (+--) on port 1 that links to the if 0 and if >= 1 cases. - Numeric operations -> an OPR node (--+) plus a NUM that holds the kind of operation as per the HVM2 paper. - References to top level functions -> REF node (+). Matches get compiled to the above core constructs according to the adt-encoding option. Check out [HVM2](https://github.com/HigherOrderCO/HVM), one of the Higher Order Company's projects, to know more about this. ### Bend compiler passes: **encode_adt**: Create functions for constructors. **desugar_open**: Convert open terms into match terms. **encode_builtins**: Convert sugars for builtin types (e.g., list, string) into function calls. **desugar_match_def**: Convert equational-style pattern matching functions into trees of match and switch terms. **fix_match_terms**: Normalize all match and switch terms. **lift_local_defs**: Convert `def` terms into top-level functions. **desugar_bend**: Convert Bend terms into top-level functions. **desugar_fold**: Convert `fold` terms into top-level functions. **desugar_with_blocks**: Convert `with` terms and ask (`<-`) terms into monadic bind and unit (wrap). **make_var_names_unique**: Give a unique name to each variable in each function. **desugar_use**: Resolve alias terms (`use`) by substituting their occurrences with the aliased term (syntactic duplication). **linearize_matches**: Linearize the variables in match and switch terms according to the linearize-matches option. **linearize_match_with**: Linearize the variables specified in `with` clauses of match and switch if they haven't already been linearized by `linearize_matches`. **type_check_book**: Run the type checker (no elaboration, only inference/checking). **encode_matches**: Transform match terms into their lambda-calculus forms as specified by the adt-encoding option. **linearize_vars**: Linearize the occurrences of variables by placing duplicates when variables are used more than once, erasing unused variables, and inlining `let` terms whose variables only occur once. **float_combinators**: Convert combinator terms into top-level functions according to the size heuristic described in the source code. **prune**: Remove unused functions according to the prune option. **merge_definitions**: Merge identical top-level functions. **expand_main**: Expand the term of the `main` function by dereferencing so that it includes computation and isn't just lazy refs or data containing lazy refs. **book_to_hvm**: Lower to HVM (as described in the compilation-and-readback file). **eta**: Perform eta-reduction at the inet level without reducing nodes with `ERA` or `NUM` at both ports (logically equivalent but looks incorrect to users). **check_cycles**: Heuristic check for mutually recursive cycles of function calls that could cause loops in HVM. **inline_hvm_book**: Inline REFs to networks that are nullary nodes. **prune_hvm_book**: Additional layer of pruning after eta-reducing at the inet level. **check_net_sizes**: Ensure no generated definition will be too large to run on the CUDA runtime. **add_recursive_priority**: Mark some binary recursive calls with a flag at the inet level so that the GPU runtime can properly distribute work. ================================================ FILE: docs/compiler-options.md ================================================ # Options | flag | Default | What it does? | | ------------------------------------------------------------------------ | ------------- | ----------------------------------------- | | `-Oall` | Disabled | Enables all compiler passes | | `-Ono-all` | Disabled | Disables all compiler passes | | `-Oeta` `-Ono-eta` | Disabled | [eta-reduction](#eta-reduction) | | `-Oprune` `-Ono-prune` | Disabled | [definition-pruning](#definition-pruning) | | `-Olinearize-matches` `-Olinearize-matches-alt` `-Ono-linearize-matches` | Enabled | [linearize-matches](#linearize-matches) | | `-Ofloat-combinators` `-Ono-float-combinators` | Enabled | [float-combinators](#float-combinators) | | `-Omerge` `-Ono-merge` | Disabled | [definition-merging](#definition-merging) | | `-Oinline` `-Ono-inline` | Disabled | [inline](#inline) | | `-Ocheck-net-size` `-Ono-check-net-size` | Disabled | [check-net-size](#check-net-size) | | `-Oadt-scott` `-Oadt-num-scott` | adt-num-scott | [adt-encoding](#adt-encoding) | | `-Otype-check` `-Ono-type-check` | type-check | [type-checking](#type-checking) | ## Eta-reduction Enables or disables Eta Reduction for defined functions. Eta reduction simplifies lambda expressions, removing redundant parameters. [See also](https://wiki.haskell.org/Eta_conversion). Example: ```py # program id = λx x id_id = λx (id x) # -Oeta id_id = id # -Ono-eta id_id = λz (id z) ``` ## Definition-pruning If enabled, removes all unused definitions. Example: ```py # program Id = λx x Id2 = Id Main = (Id 42) # -Oprune Id = λx x Main = (Id 42) # -Ono-prune Id = λx x Id2 = Id Main = (Id 42) ``` ## Definition-merging If enabled, merges definitions that are identical at the term level. Example: ```py # Original program id = λx x also_id = λx x main = (id also_id) # After definition merging id_$_also_id = λx x main = (id also_id) # -Ono-merge, compilation output @also_id = (a a) @id = (a a) @main = a & @id ~ (@also_id a) # -Omerge, compilation output @a = (a a) @main = a & @a ~ (@a a) ``` ## linearize-matches Linearizes the variables between match cases, transforming them into combinators when possible. ```py # Linearization means going from this @a @b switch a { 0: (Foo b) _: (Bar a-1 b) } # To this @a @b (switch a { 0: @b (Foo b) _: @b (Bar a-1 b) } b) ``` When the `linearize-matches` option is used, only linearizes variables that would generate an eta-reducible application. Example: ```py λa λb switch a { 0: b; _: b } # Is transformed to λa switch a { 0: λb b; _: λb b } # But this stays the same λa λb switch b { 0: a; _: a } ``` When the `linearize-matches-extra` option is used, it linearizes all variables used in the arms. example: ```py λa λb λc switch b { 0: a; _: c } # Is transformed to (without eta-reducing 'c') λa λb λc (switch b { 0: λa λc a; _: λa λc c } a c) ``` These automatic linearization passes are done before the manual linearization from `with` and doesn't duplicate manually linearized variables. ```py # These variables are only linearized once λa λb λc switch a with b c { 0: (b c); _: (a-1 b c) } # With -Olinearize-matches becomes λa λb λc (switch a { 0: λb λc (b c); _: λb λc (a-1 b c) } b c) # And not λa λb λc (switch a { 0: λb λc λb λc (b c); _: λb λc λb λc (a-1 b c) } b c b c) ``` ## float-combinators Extracts closed terms to new definitions. See [lazy definitions](lazy-definitions.md#automatic-optimization). Since HVM-Core is an eager runtime, this pass is enabled by default to prevent infinite expansions. Example: ```py True = λt λf λm t False = λt λf λm f Maybe = λx λt λf λm (m x) getVal = λb (b 1 0 (λx (== x 1))) # `(λx (== x 1))` can be extracted, since there is no free variables. Cons = λh λt λc λn (c h t) Nil = λc λn n fold = λinit λf λxs (xs λh λt (fold (f init h) f t) init) # Here we need to extract `λh λt (fold (f init h) f t)` to not expand `fold` infinitely, but it will not be extracted because of the free variable `init`. ``` # Inline If enabled, inlines terms that compile to nullary inet nodes (refs, numbers, erasures). Example: ```py # program foo = 2 id = λx x main = (id foo) # -Ono-inline, compilation output @foo = 2 @id = (a a) @main = a & @id ~ (@foo a) # -Oinline, compilation output @foo = 2 @id = (a a) @main = a & @id ~ (2 a) ``` ## Check-net-size If enabled, checks that the size of each function after compilation has at most 64 HVM nodes. This is a memory restriction of the CUDA runtime, if you're not using the `*-cu` you can disable it. Example: ```py # Without -Ocheck-net-size compiles normally. # But with -Ocheck-net-size it fails with # `Definition is too large for hvm` (Radix n) = let r = Map_/Used let r = (Swap (& n 1) r Map_/Free) let r = (Swap (& n 2) r Map_/Free) let r = (Swap (& n 4) r Map_/Free) let r = (Swap (& n 8) r Map_/Free) let r = (Swap (& n 16) r Map_/Free) let r = (Swap (& n 32) r Map_/Free) let r = (Swap (& n 64) r Map_/Free) let r = (Swap (& n 128) r Map_/Free) let r = (Swap (& n 256) r Map_/Free) let r = (Swap (& n 512) r Map_/Free) let r = (Swap (& n 1024) r Map_/Free) let r = (Swap (& n 2048) r Map_/Free) let r = (Swap (& n 4096) r Map_/Free) let r = (Swap (& n 8192) r Map_/Free) let r = (Swap (& n 16384) r Map_/Free) let r = (Swap (& n 32768) r Map_/Free) let r = (Swap (& n 65536) r Map_/Free) let r = (Swap (& n 131072) r Map_/Free) let r = (Swap (& n 262144) r Map_/Free) let r = (Swap (& n 524288) r Map_/Free) let r = (Swap (& n 1048576) r Map_/Free) let r = (Swap (& n 2097152) r Map_/Free) let r = (Swap (& n 4194304) r Map_/Free) let r = (Swap (& n 8388608) r Map_/Free) r ``` ## ADT Encoding Selects the lambda encoding for types defined with `type` and `object`. `-Oadt-scott` uses Scott encoding. `-Oadt-num-scott` uses a variation of Scott encoding where instead of one lambda per constructor, we use a numeric tag to indicate which constructor it is. The numeric tag is assigned to the constructors in the order they are defined and each tag is accessible as a definition by `//tag`. ```py # Generates functions Option/Some and Option/None type Option: Some { value } None # With -Oadt-scott they become: Option/Some = λvalue λSome λNone (Some value) Option/None = λSome λNone (None) # With -Oadt-num-scott they become: Option/Some = λvalue λx (x Option/Some/tag value) Option/None = λx (x Option/None/tag) # Generated -Oadt-num-scott tags: Option/Some/tag = 0 Option/None/tag = 1 ``` Pattern-matching with `match` and `fold` is generated according to the encoding. Note: IO is **only** available with `-Oadt-num-scott`. ## Type Checking Type checking is enabled by default and verifies and enforces the constraints of types. When enabled, verifies the type safety of the program based on the source code. If it passes the check, then the program is guaranteed to satisfy type constraints for all possible inputs. ```py def main() -> Bool: return 3 ``` With type checking enabled, The following program will throw a type error `Expected function type 'Bool' but found 'u24'`, whereas if it is disabled, it will compile successfully and return `3`. ================================================ FILE: docs/defining-data-types.md ================================================ # Defining data types It is possible to easily define complex data types using the `type` keyword. ```py # A Boolean is either True or False type Bool: True False ``` If a constructor has any arguments, parentheses are necessary around it: ```py # An option either contains some value, or None type Option: Some { value } None ``` If the data type has a single constructor, it can be destructured using `open`: ```py # A Box is a wrapper around a value. type Boxed: Box { value } def main() -> _: b = Boxed/Box(1) open Boxed: b return b.value ``` The fields of the constructor that is being destructured with the `match` are bound to the matched variable plus `.` and the field names. ```py opt = Option/Some(1) match opt: case Option/Some: return opt.value case Option/None: return 0 ``` Rules can also have patterns. They work like match expressions with explicit bindings: ```py (Option.map (Some value) f) = (Some (f value)) (Option.map None f) = None ``` However, they also allow matching on multiple values at once, which is something that regular `match` can't do: ```py type Boolean: True False (Option.is_both_some (Some lft_val) (Some rgt_val)) = True (Option.is_both_some lft rgt) = False ``` You can read more about pattern matching rules in [Pattern matching](/docs/pattern-matching.md). In conclusion, the `type` keyword is very useful as it allows you to easily create data types and deconstruct them. ================================================ FILE: docs/dups-and-sups.md ================================================ # Dups and sups Term duplication is done automatically when a variable is used more than once. But it's possible to manually duplicate a term using `let`. This type of statement is called `dup` or `duplication`. ```py # the number 2 in church encoding using let. ch2 = λf λx let {f1 f2} = f; (f1 (f2 x)) # the number 3 in church encoding using let. ch3 = λf λx let {f0 f1} = f; let {f2 f3} = f0; (f1 (f2 (f3 x))) ``` A `sup` is a superposition of two values, it is defined using curly brackets with two terms inside. A superposition is the opposite of a duplication. ```py sup = {3 7} ``` Sups can be used anywhere a value is expected, if anything interacts with the superposition, the result is the superposition of that interaction on both the possible values: ```py mul = λa λb (* a b) result = (mul 2 5) # returns 10 result_sup = (mul 2 {5 7}) # returns {10 14} multi_sup = (mul {2 3} {5 7}) # returns {{10 14} {15 21}} ``` If we pair a superposition with a duplication, the result is that they behave like constructing and destructing a pair: ```py # each dup variable now has a copy of the {1 2} superposition let {x1 x2} = {1 2} ``` Due to how duplications are compiled, when two dups interact, they destructively interfere with each other. In this case the result doesn't follow the expected behavior (it's well defined at the HVM level, but is incorrect at a lambda-calculus level). That imposes a strong restriction on correct Bend programs: a variable should not duplicate another variable that itself duplicates some variables. The program below is an example where this can go wrong when using higher-order functions. ```py def List/map(xs: List(A), f: A -> B) -> List(B): fold xs: case List/Nil: return List/Nil case List/Cons: # 'f' is duplicated here return List/Cons(f(xs.head), List/map(xs.tail, f)) # This line above is converted by the compiler to an explicit duplication of 'f' # {f1 f2} = f # return List/Cons(f1(xs.head), List/map(xs.tail, f2)) def main() -> _: # This lambda duplicates `x` and is itself duplicated by the map function. # This will result in wrong behavior. # In this specific case, the runtime will catch it and generate an error, # but at the moment that is not always the case. return List/map([1, 2, 3], lambda x: (+ x x)) ``` In this case, we can only have one source of duplication, or our results will be incorrect. Either List/map is linear (doesn't duplicate `f`) or the passed function is linear (doesn't duplicate `x` or any other variable inside it). ================================================ FILE: docs/ffi.md ================================================ # Dynamically linked libraries and foreign functions We can add new IO functions to Bend during runtime by loading dynamic libraries. ## Using IO dynamic libraries in Bend Here is an example of how we could load a Bend library that contains functions for working with directories. ```py def main(): with IO: # Open the dynamic library file # The second argument is '0' if we want to load all functions immediately. # Otherwise it should be '1' when we want to load functions as we use them. # 'dl' is the unique id of the dynamic library. dl <- IO/DyLib/open("./libbend_dirs.so", 0) # We can now call functions from the dynamic library. # We need to know what functions are available in the dynamic library. # If you're writing a library for Bend that uses a dynamically linked library # you should wrap the IO calls so that users don't need to know what's in the dynamic library. # The first argument is the dynamic library id. # The second argument is the name of the function we want to call as a String. # The third argument are the arguments to the function. # You need to know the types of the arguments and the return type of the function. # In our example, 'ls' receives a path as a String and # returns a String with the result of the 'ls' command. unwrapped_dl = Result/unwrap(dl) files_bytes <- IO/DyLib/call(unwrapped_dl, "ls", "./") files_str = String/decode_utf8(Result/unwrap(files_bytes)) files = String/split(files_str, '\n') # We want to create a directory for a new user "my_user" if it doesn't exist. my_dir = List/filter(files, String/equals("my_dir")) match my_dir: case List/Cons: # The directory already exists, do nothing. * <- IO/print("Directory already exists.\n") status = wrap(-1) case List/Nil: # The directory doesn't exist, create it. * <- IO/DyLib/call(unwrapped_dl, "mkdir", "./my_dir") * <- IO/print("Directory created.\n") status = wrap(+0) status <- status # Here the program ends so we didn't need to close the dynamic library, # but it's good practice to do so once we know we won't need it anymore. * <- IO/DyLib/close(unwrapped_dl) return wrap(status) ``` ## Writing IO dynamic libraries for Bend Bend IO libraries need to be implemented in C or Cuda (depending on the backend you're targeting) using the HVM API. ### Writing libraries for the C runtime The functions you call from Bend using `IO/DyLib/call` must have the following signature: ```c Port function_name(Net* net, Book* book, Port arg); ``` Where: - `net` is a pointer to the current network state. - `book` is a pointer to the book of function definitions. - `arg` is a pointer to the arguments of the function. The return value must be a `Port` that points to the return value of the function. HVM provides some util functions to do the conversions from HVM to C and vice versa, so that you don't need to understand the details of the HVM runtime. We can implement the example library from earlier for the C runtime with the following C code: ```c // This is a header file that contains the HVM API. #include "hvm.h" // The headers we need to open and read directories. #include #include #include #include // IO functions must have this exact signature. // The first argument is a pointer to the graph with the current state of the program. // The second argument is a pointer to the book of function definitions. // The third argument points to the arguments of the function. // The return value must be a port that points to the return value of the function. Port ls(Net* net, Book* book, Port arg) { // The arguments first need to be converted from HVM to C. // For the 'ls' function, this is just a single string. Str path = readback_str(net, book, arg); // Now we can do the actual IO operations. // In this case, we list the contents of the directory // by calling the 'ls' program as a subprocess. char* cmd = malloc(path.len + strlen("ls ") + 1); sprintf(cmd, "ls %s", path.buf); free(path.buf); FILE* pipe = popen(cmd, "r"); if (pipe == NULL) { // It'd be best practice to return a Result type instead of a null value (ERA). // If this command fails and the calling Bend program tries to use the result, // it will get corrupted and spit out garbage. fprintf(stderr, "failed to run command '%s': %s\n", cmd, strerror(errno)); return new_port(ERA, 0); } char buffer[512]; Bytes output = { .buf = NULL, .len = 0 }; while (fgets(buffer, sizeof(buffer), pipe) != NULL) { size_t len = strlen(buffer); char* new_result = realloc(output.buf, output.len + len + 1); if (new_result == NULL) { fprintf(stderr, "failed to allocate space for output of '%s': %s\n", cmd, strerror(errno)); free(cmd); free(output.buf); pclose(pipe); return new_port(ERA, 0); } output.buf = new_result; strcpy(output.buf + output.len, buffer); output.len += len; } // After we're done with the operation, we convert it to HVM format. // In this case, the output is the output of the 'ls' command as a list of bytes. // We need to process it in Bend later to convert it to a list of file names. Port output_port = inject_bytes(net, &output); // Remember to free all the allocated memory. free(cmd); free(output.buf); pclose(pipe); return output_port; } Port mkdir(Net* net, Book* book, Port arg) { // We do the same thing here as in the 'ls' function, // except we call 'mkdir' which doesn't output anything. Str path = readback_str(net, book, arg); char* cmd = malloc(path.len + strlen("mkdir ") + 1); sprintf(cmd, "mkdir %s", path.buf); int res = system(cmd); free(path.buf); free(cmd); return new_port(ERA, 0); } ``` To compile this code into a library, we can use the `gcc` compiler and include the HVM header files. Assuming that it's saved in a file called `libbend_dirs.c`, we can compile it with the following command: ```sh # Needs to be compiled as a shared library with unresolved symbols. # For macOS: gcc -shared -o libbend_dirs.so -I /path/to/HVM/src/ libbend_dirs.c -undefined dynamic_lookup -fPIC # For Linux: gcc -shared -o libbend_dirs.so -I /path/to/HVM/src/ libbend_dirs.c -Wl,--unresolved-symbols=ignore-all -fPIC ``` Now we can use the dynamic library in our Bend program, we just need to pass the path to the library to `IO/DyLib/open`. ### Writing libraries for the Cuda runtime Writing libraries for the Cuda runtime is very similar to writing libraries for the C runtime. The main difference is the function signature: ```c++ Port function_name(GNet* gnet, Port argm) ``` Where: - `gnet` is a pointer to the current network state. - `argm` is the argument to the function. The return value must be a `Port` that points to the return value of the function. To compile libraries of the Cuda runtime, we can use the `nvcc` compiler and include the HVM header files. Assuming that it's saved in a file called `libbend_dirs.cu`, we can compile it with the following command: ```sh nvcc -shared -o libbend_dirs.so -I /path/to/hvm/ libbend_dirs.cu ``` ### Compiling Bend programs that use dynamic libraries To compile the C or Cuda program generated from a Bend program that uses dynamic libraries, we need to use the `-rdynamic` flag to allow the dynamic library to use symbols from the main program. For example, if we have a Bend program called `main.bend` that uses the dynamic library `libbend_dirs.so`, we need compile to it with the following commands: ```sh # Compiling for C bend gen-c my_app.bend > my_app.c gcc -rdynamic -lm my_app.c -o my_app # Compiling for Cuda bend gen-cu my_app.bend > my_app.cu nvcc --compiler-options=-rdynamic my_app.cu -o my_app ``` ================================================ FILE: docs/imports.md ================================================ # Import System ## Case Sensitivity All import paths are case-sensitive. Ensure that the case used in import statements matches exactly with the file and directory names. ## Syntax Imports can be declared two ways: ```py from path import name # or import path/name # We recommend always placing the imports at the top of the file. ``` ## Project Structure Let's assume we have a bend project with the following structure: ``` my_project/ ├── main.bend ├── utils/ │ ├── helper.bend │ │ └── def calc │ └── math.bend │ ├── def add │ └── def subtract ``` ## Importing Relative Paths Paths starting with `./` or `../` are imported relative to the file. ### Example: ```py # if used inside `my_project/*.bend` from ./utils import helper # if used inside `my_project/*/*.bend` import ../utils/helper ``` This will bind `calc` from `helper.bend` as `helper/calc`. ## Importing Absolute Paths Otherwise, paths imported are relative to the folder of the main file. ### Example: ```py from utils import math # or import utils/math ``` This will bind `add` and `subtract` from `math.bend` as `math/add` and `math/subtract`. ## Importing Specific Top-Level Names You can import specific top-level names from a file. ### Example: ```py from utils/helper import calc from utils/math import (add, subtract) # or import (utils/helper/calc, utils/math/add, utils/math/subtract) # or import utils/helper/calc import utils/math/add import utils/math/subtract ``` This will bind the names `calc`, `add` and `subtract` from their respective files. ## Importing All Names You can import all top-level names from a file using the wildcard `*`. ### Example: ```py from utils/math import * ``` This will bind the names `add` and `subtract` from `math.bend`. ## Importing All `.bend` Files from a Folder You can import all `.bend` files from a folder using the wildcard `*`. ### Example: ```py from utils import * ``` This will bind the names from `helper.bend` and `math.bend`, as `helper/calc`, `math/add` and `math/subtract`. ## Aliasing Imports You can alias imports to a different name for convenience. ### Importing a File with Alias Import the `file` top-level name from `file.bend` aliased to `alias`, and all other names as `alias/name`. ### Example: ```py from utils import helper as utilsHelper import utils/math as mathLib ``` This will bind the names from `helper.bend` and `math.bend`, as `utilsHelper/calc`, `mathLib/add` and `mathLib/subtract`. ### Importing Specific Names with Aliases You can import specific top-level names and alias them to different names. ### Example: ```py from utils/helper import calc as calcFunc from utils/math import (add as addFunc, subtract as subFunc) # or import (utils/math/add as addFunc, utils/math/subtract as subFunc) ``` This will bind `calc`, `add` and `subtract` as `calcFunc`, `addFunc` and `subFunc` from their respective files. ## Project Structure Let's assume we have a bend project with the following structure: ``` my_project/ ├── main.bend ├── types/ │ ├── List.bend │ │ └── type List: Nil | (Cons ..) │ └── List/ │ ├── concat.bend │ │ └── def concat │ └── append.bend │ └── def append │ └── def helper ``` ## Importing data types You can import a data type and its constructors by only importing its name. ### Example: ```py from types/List import List # behaves the same as from types/List import (List, List/Nil, List/Cons) ``` Importing only `List` from `List.bend` will import the type `List` and bind its constructors name `List/Nil` and `List/Cons`. ## Importing files with a top level name equal to its name When a file and a top-level name in it share a name, for example, `List.bend`, `concat.bend` and `append.bend`, the bind of that import is simplified to the file name. ### Example: ```py from types/List import append ``` This will bind `append` and `append/helper` from `append.bend`. ## Files and directories with the same name When files and directories share a name, both share the import namespace: ```py from types/List import (List, concat) ``` This will attempt to import from both the `List.bend` file and the `List` folder, resulting in the binds `List/Nil`, `List/Cons` and `concat`. ```py from types/List import * ``` This will import all the names from `List.bend`, then all the files inside the `List` folder, resulting in the binds `List/Nil`, `List/Cons`, `concat`, `append` and `append/helper`. In both cases, if a name is present as a top-level name on the file, and as a `.bend` file name inside the folder, it will result in an error. If you only want to import `List.bend` and not search the files in its folder, you can use the `import path` syntax: ```py import types/List ``` ================================================ FILE: docs/lazy-definitions.md ================================================ # Making recursive definitions lazy In strict-mode, some types of recursive terms will unroll indefinitely. This is a simple piece of code that works on many other functional programming languages but hangs on Bend due to the strict evaluation of HVM2. ```rust Cons = λx λxs λcons λnil (cons x xs) Nil = λcons λnil nil Map = λf λlist let cons = λx λxs (Cons (f x) (Map f xs)) let nil = Nil (list cons nil) Main = (Map λx (+ x 1) (Cons 1 Nil)) ``` The recursive `Map` creates an infinite reduction sequence because each recursive call expands into another call to Map, never reaching a base case. Which means that functionally, it will reduce it infinitely, never reaching a normal form. For similar reasons, if we try using Y combinator it also won't work. ```rust Y = λf (λx (f (x x)) λx (f (x x))) Map = (Y λrec λf λlist let cons = λx λxs (Cons (f x) (rec f xs)) let nil = Nil (list cons nil f)) ``` By linearizing `f`, the `Map` function only expands after applying the argument `f`, because the `cons` function will be lifted to a separate top-level function by the compiler (when this option is enabled). ```rust Map = λf λlist let cons = λx λxs λf (Cons (f x) (Map f xs)) let nil = λf Nil (list cons nil f) ``` This code will work as expected, since `cons` and `nil` are lambdas without free variables, they will be automatically floated to new definitions if the [float-combinators](compiler-options.md#float-combinators) option is active, allowing them to be unrolled lazily by hvm. The recursive part of the function should be part of a combinator that is not in an active position. That way it can be lifted into a top-level function which is compiled into a lazy reference thus preventing the infinite expansion. [Supercombinators](https://en.wikipedia.org/wiki/Supercombinator) can be used in order to ensure said lazy unrolling of recursive terms. Other combinator patterns can work as well, as long as they're lifted to the top level. If you have a set of mutually recursive functions, you only need to make one of the steps lazy. This might be useful when doing micro-optimizations, since it's possible to avoid part of the small performance cost of linearizing lambdas. ### Automatic optimization Bend carries out [match linearization](compiler-options.md#linearize-matches) and [combinator floating](compiler-options.md#float-combinators) optimizations, enabled through the CLI, which are active by default in strict mode. Consider the code below: ```rs Zero = λf λx x Succ = λn λf λx (f n) ToMachine = λn (n λp (+ 1 (ToMachine p)) 0) ``` The lambda terms without free variables are extracted to new definitions. ```rs ToMachine0 = λp (+ 1 (ToMachine p)) ToMachine = λn (n ToMachine0 0) ``` Definitions are lazy in the runtime. Floating lambda terms into new definitions will prevent infinite expansion. It's important to note that preventing infinite expansion through simple mutual recursion doesn't imply that a program lacks infinite expansion entirely or that it will terminate. ================================================ FILE: docs/native-numbers.md ================================================ # Native numbers Currently Bend supports 3 types of native numbers for fast numeric operations (compared to lambda-encoded numbers): - U24: Unsigned integers (24 bits) - I24: Signed integers (24 bits, two's complement) - F24: Floating point numbers (single precision IEEE-754 floating point with the last bits of the mantissa implicitly set to zero) ### U24 Unsigned numbers are written as just the number and are represented as a 24 bit unsigned integer. ```rs two = 2 ``` ### I24 Signed numbers are written with a `+` or `-` sign and are represented as a 24 bit two's complement integer. ```rs minus_two = -2 plus_0 = +0 ``` Positive numbers _must_ be written with a `+` sign, otherwise they'll be interpreted as unsigned. Numbers can also be written in binary or hexadecimal form. Underscores can be optionally used as digit separators to make large numbers more readable. ```rs decimal = 1194684 binary = 0b100_100_011_101_010_111_100 hexadecimal = 0x123_abc hex_signed = -0xbeef ``` ### F24 Floating point numbers must have the decimal point `.` and can optionally take a sign `+` or `-`. They are represented as IEEE-754 single precision floating point numbers with the last bits of the mantissa implicitly set to zero. ```py one = 1.0 pi = +3.1415926535897932384626433 # Will get rounded to 24bit float a_millionth = 0.000001 zero = 0.0 minus_zero = -0.0 ``` ### Mixing number types The three number types are fundamentally different. At the HVM level, both type and the operation are stored inside the number nodes as tags. One number stores the type, the other the operation. That means that we lose the type information of one of the numbers, which causes this behavior. During runtime, the executed numeric function depends on both the type tag and the operation tag. For example, the same tag is used for unsigned bitwise and floating point atan2, so if you mix two numbers of different types, HVM will interpret the binary representation of one of them incorrectly, leading to incorrect results. Which number is interpreted incorrectly depends on the situation and shouldn't be relied on for now. Instead, you should make sure that all numbers are of the same type. #### Casting numbers There is a way to convert between the different number types, and using it is very easy, here's an example: ```py def main() -> _: x = f24/to_i24(1.0) y = u24/to_f24(2) z = i24/to_u24(-3) return (x, y, z) ``` You can find more number casting functions and their declarations at [builtins.md](docs/builtins.md). ### Operations There is also support for native operations. In "Imp" syntax they are infix operators and in "Fun" syntax they are written in reverse polish notation (like you'd call a normal function). Each operation takes two arguments and returns a new number. ```rs # In Fun syntax some_val = (+ (+ 7 4) (* 2 3)) ``` These are the currently available operations: | Operation | Description | Accepted types | Return type | | --------- | ------------------------ | -------------- | ----------------- | | \+ | Addition | U24, I24, F24 | Same as arguments | | \- | Subtraction | U24, I24, F24 | Same as arguments | | \* | Multiplication | U24, I24, F24 | Same as arguments | | \/ | Division | U24, I24, F24 | Same as arguments | | \% | Modulo | U24, I24, F24 | Same as arguments | | \== | Equality | U24, I24, F24 | U24 | | \!= | Inequality | U24, I24, F24 | U24 | | \< | Less than | U24, I24, F24 | U24 | | \<= | Less than or equal to | U24, I24, F24 | U24 | | \> | Greater than | U24, I24, F24 | U24 | | \>= | Greater than or equal to | U24, I24, F24 | U24 | | \& | Bitwise and | U24, I24 | Same as arguments | | \| | Bitwise or | U24, I24 | Same as arguments | | \^ | Bitwise xor | U24, I24 | Same as arguments | | \*\* | Exponentiation | F24 | F24 | ### Functions | Name | Description | Accepted types | Return type | | -------------- | ------------------------------- | -------------- | ----------- | | `log(x, base)` | Logarithm | F24 | F24 | | `atan2(x, y)` | 2 arguments arctangent (atan2f) | F24 | F24 | ### Pattern matching Bend also includes a `switch` syntax for pattern-matching U24 numbers. ```rs Number.to_church = λn λf λx switch n { 0: x _: (f (Number.to_church n-1 f x)) } ``` The `0` case matches when `n` is 0, and the `_` case matches when `n` is greater than 0. In the `_` arm, we can access the predecessor of `n` with the `n-1` variable. We can also match on more than one value at once. To do that, we must cover the cases in order, starting from 0. ```rs Number.minus_three = λn λf λx switch n { 0: 0 1: 0 2: 0 _: n-3 } ``` Using everything we learned, we can write a program that calculates the n-th Fibonacci number using native numbers: ```py fibonacci = λn # n is the argument switch n { # If the number is 0, then return 0 0: 0 # If the number is 1, then return 1 1: 1 # Otherwise, return the sum of (fib (n-2 + 1)) and (fib n-2) # The successor pattern provides a `var`-`successor number` bind _: (+ (fibonacci (+ n-2 1)) (fibonacci n-2)) } main = (fibonacci 15) ``` ### Pattern matching numbers in Fun syntax equations In Fun syntax, we can also use pattern matching equations to match on native unsigned numbers. ```rs (fib 1) = 1 (fib 0) = 0 (fib n) = (+ (fib (- n 1)) (fib (- n 2))) ``` Unlike with `switch`, you can match any number and in any order. The variable pattern is used to match on all other numbers. Unlike with `switch`, you can't directly access the predecessor of the number. You can read [Pattern matching](pattern-matching.md) for more information about how pattern matching equations are converted to `switch` and `match` expressions. ================================================ FILE: docs/pattern-matching.md ================================================ # Pattern Matching Switches on many numbers are compiled to sequences of simple switch expressions: ```py # These two are equivalent switch n { 0: A 1: B 2: C _: (D n-3) } switch n { 0: A _: switch n-1 = n-1 { 0: B _: switch n-2 = n-1-1 { 0: C _: use n-3 = n-2-1; (D n-3) } } } ``` Matches on ADT constructors are compiled to different expressions depending on the chosen encoding: ```py type Maybe = (Some val) | None UnwrapOrZero x = match x { Maybe/Some: x.val Maybe/None: 0 } # If the current encoding is 'adt-num-scott' it becomes: Maybe/Some = λval λx (x 0 val) Maybe/None = λx (x 1) UnwrapOrZero x = (x λtag switch tag { 0: λx.val x.val _: λ* 0 }) # Otherwise, if the current encoding is 'adt-scott' it becomes: Maybe/Some = λval λMaybe/Some λMaybe/None (Maybe/Some val) Maybe/None = λMaybe/Some λMaybe/None Maybe/None UnwrapOrZero x = (x λx.val x.val 0) ``` ### Pattern Matching functions Besides `match`and `switch` terms, Bend also supports equational-style pattern matching functions. ```py And Bool/True b = b And Bool/False * = Bool/False ``` There are advantages and disadvantages to using this syntax. They offer more advanced pattern matching capabilities and also take care linearizing variables to make sure that recursive definitions work correctly in strict evaluation mode, but take away your control of how the pattern matching is implemented and can be a bit more resource intensive in some cases. Pattern matching equations are transformed into a tree of `match` and `switch` terms from left to right. ```py # These two are equivalent (Foo 0 Bool/False (List/Cons h1 (List/Cons h2 t))) = (Bar h1 h2 t) (Foo 0 * *) = Baz (Foo n Bool/False *) = n (Foo n Bool/True *) = 0 Foo = λarg1 λarg2 λarg3 (switch arg1 { 0: λarg2 λarg3 match arg2 { Bool/True: λarg3 Baz Bool/False: λarg3 match arg3 { List/Cons: (match arg3.tail { List/Cons: λarg3.head (Bar arg3.head arg3.tail.head arg3.tail.tail) List/Nil: λarg3.head Baz } arg3.head) List/Nil: Baz } } _: λarg2 λarg3 (match arg2 { Bool/True: λarg1 0 Bool/False: λarg1 arg1 } arg1) } arg2 arg3) ``` Besides the compilation of complex pattern matching into simple `match` and `switch` expressions, this example also shows how some arguments are pushed inside the match. When compiling for strict evaluation, by default any variables that are used inside a match get linearized by adding a lambda in each arm and an application passing its value inwards. To ensure that recursive pattern matching functions don't loop in strict mode, it's necessary to make the match arms combinators, so that they can be converted into separate functions and a lazy reference is used in the match arm. ```py # This is what the Foo function actually compiles to. # With -Olinearize-matches and -Ofloat-combinators (default on strict mode) # Main function (Foo) = λa λb λc (switch a { 0: Foo__C8; _: Foo__C9; } b c) # Case 0 branch (Foo__C8) = λa λb (a Foo__C5 b) # Foo.case_0 (Foo__C5) = λa switch a { 0: λ* Baz; _: Foo__C4; } # Foo.case_0.case_true (Foo__C4) = λ* λa (a Foo__C3) # Foo.case_0.case_false (Foo__C3) = λa switch a { 0: Baz; _: Foo__C2; } # Foo.case_0.case_false_cons (Foo__C2) = λ* λa λb (b Foo__C1 a) # Foo.case_0.case_false_cons_cons (Foo__C1) = λa switch a { 0: λ* Baz; _: Foo__C0; } # Foo.case_0.case_false_cons_nil (Foo__C0) = λ* λa λb λc (Bar c a b) # Foo.case_0.case_false_nil # Case non-zero branch (Foo__C9) = λa λb λc (b Foo__C7 c a) # Foo.case_+ (Foo__C7) = λa switch a { 0: λ* λ* 0; _: Foo__C6; } # Foo.case_+.case_false (Foo__C6) = λ* λ* λa (+ a 1) # Foo.case_+.case_true # As an user, you can't write a function with __ on its name, that sequence is reserved for things generated by the compiler. ``` Pattern matching equations also support matching on non-consecutive numbers: ```rust Parse '(' = Token.LParenthesis Parse ')' = Token.RParenthesis Parse 'λ' = Token.Lambda Parse n = (Token.Name n) ``` The compiler transforms this into an optimized cascade of switch expressions. Each switch computes the distance from the smallest character to efficiently test each case: ```py Parse = λarg0 switch matched = (- arg0 '(') { 0: Token.LParenthesis # ')' + 1 - '(' is resolved during compile time _: switch matched = (- matched-1 ( ')'-1-'(' ) { 0: Token.RParenthesis _: switch matched = (- matched-1 ( 'λ'-1-')' ) { 0: Token.Lambda _: use n = (+ 1 matched-1); (Token.Name n) } } } ``` Unlike with `switch`, with pattern matching equations you can't access the value of the predecessor of the matched value directly, but instead you can match on a variable. Instead, variables (like n above) are bound to computed expressions based on the matched value. Notice how in the example above, `n` is bound to `(+ 1 matched-1)`. Notice that this definition is valid, since `*` will cover both `p` and `0` cases when the first argument is `False`.This example shows how patterns are considered from top to bottom, with wildcards covering multiple specific cases: ```rust pred_if Bool/False * if_false = if_false pred_if Bool/True p * = (- p 1) pred_if Bool/True 0 * = 0 ``` Pattern matching on strings and lists desugars to a list of matches on Cons and Nil ```py Hi "hi" = 1 Hi _ = 0 Foo [] = 0 Foo [x] = x Foo _ = 3 # Becomes: Hi (String/Cons 'h' (String/Cons 'i' String/Nil)) = 2 Hi _ = 0 Foo List/Nil = 0 Foo (List/Cons x List/Nil) = x Foo _ = 3 ``` ================================================ FILE: docs/syntax.md ================================================ # Syntax This file provides a reference of each possible syntax of bend programming language. Click [here](#imp-syntax) to see the syntax for "imp", the variant of bend that looks like an imperative language like python. Click [here](#fun-syntax) to see the syntax for "fun", the variant of bend that looks like a functional language like Haskell or ML. Click [here](#import-syntax) to see the import syntax. Click [here](#comments) to see the syntax for commenting code. Click [here](#imp-type-syntax) to see the imperative type syntax. Click [here](#fun-type-syntax) to see the functional type syntax. Both syntaxes can be mixed in the same file like the example below: ```python object Point { x, y } type MyTree = (Node ~left ~right) | (Leaf value) type Bool: True False #{ The identity function is a function that always returns the value that was used as its argument. #} def identity(x): return x main = let result = (identity 41) (+ result 1) ```
# Imp Syntax ## Top-level definitions ### Def Defines a top level function. ```python def add(x: u24, y: u24) -> u24: result = x + y return result def unchecked two() -> u24: return 2 def main() -> u24: return add(40, two) ``` A function definition is composed by a name, a sequence of parameters and a body. A top-level name can be anything matching the regex `[A-Za-z0-9_.-/]+`, except it can't have `__` (used for generated names) or start with `//`. The last statement of each function must either be a `return` or a selection statement (`if`, `switch`, `match`, `fold`) where all branches `return`. Each parameter of the function can receive a type annotation with `param_name: type` and the return value of the function can also be annotated with `def fn_name(args) -> return_type:`. We can force the type-checker to run or not on a specific function by adding `checked` or `unchecked` between `def` and the function name. ### Type Defines an algebraic data type. ```python type Option: Some { value } None type Tree(T): Node { value: T, ~left: Tree(T), ~right: Tree(T) } Leaf ``` Type names must be unique, and should have at least one constructor. For a generic or polymorphic type, all type variables used in the constructors must be declared first in the type definition with `type Name(type_var1, ...):` Each constructor is defined by a name followed by its fields. The fields can be annotated with types that will be checked when creating values of that type. The `~` notation indicates a recursive field. To use `fold` statements with a type its recursive fields must be correctly marked with `~`. The constructor names inherit the name of their types and become functions (`Tree/Node` and `Tree/Leaf` in this case). The exact function they become depends on the encoding. Read [defining data types](./defining-data-types.md) to know more. ### Object Defines a type with a single constructor (like a struct, a record or a class). ```python object Pair(A, B) { fst: A, snd: B } object Function(T) { name: String, args, body: T } object Vec { len, data } ``` The constructor created from this definition has the same name as the type. Since it only has one constructor, `fold`ing a recursive `object` requires some additional stop condition apart from pattern matching on the value itself (like an `if` statement). ## Statements ### Assignment ```python value = 2 return value (first, second) = (1, 2) return second {x y} = {2 3} ``` Assigns a value to a variable. It's possible to assign to a pattern, like a tuple or superposition, which will destructure the value returned by the expression. ```python (first, second) = (1, 2) first, second = 1, 2 ``` ### Use ```rust use x = 2 + 3 return x + x ``` Inline copies of the declared bind, it is equivalent to this code: ```rust return ((2 + 3) + (2 + 3)) ``` ### In-Place Operation ```python x += 1 return x ``` The in-place operation does an infix operation and re-assigns a variable. The operations are: - Addition `+=` - Subtraction `-=` - Multiplication `*=` - Division `/=` - Bit And `&=` - Bit Or `|=` - Bit Xor `^=` - Mapper `@=` The mapper in-place operation applies a function and re-assigns the variable: ```python x = "hello" x @= String/uppercase ``` ### Return ```python return "hello" ``` Returns the expression that follows. The last statement of each branch of a function must be a `return`. ```py # Allowed, all branches return def max(a, b): if a > b: return a else: return b ``` ```py # Not allowed, early return def Foo(x): if test_condition(x): return "err" else: y = map(x) return y ``` ```py # Not allowed, one of the branches doesn't return def Foo(a, b): if a < b: return a else: c = a + b ``` ### If ```python if condition: return 0 else: return 1 ``` A branching statement where `else` is mandatory. The condition must return a `u24` number, where 0 will run the `else` branch and any other value will return the first one. It is possible to make if-chains using `elif`: ```python if condition1: return 0 elif condition2: return 1 elif condition3: return 2 else: return 3 ``` The conditions are evaluated in order, one by one, stopping at the first successful case. ### Switch ```python switch x = 5: case 0: return 6 case 1: return 7 case _: return x-2 ``` A switch binds a variable name to the result of a given condition and branches to the case matching its value. Cases must be listed from least to greatest, beginning with `0` and incrementing by 1. The last case must be `_`, which catches all values not explicitly enumerated. Switches may only be used with native numbers values. In the last case, the predecessor value is available with the name `bound_var-next_num`, where `bound_var` is the variable set by the condition and `next_num` is the expected value of the next case. For example, the above example code returns `3`, since `x-2` is bound to `5 - 2` and the value of `x` doesn't match any explicit case. This switch statement is equivalent to the `if` from the previous section: ```python switch _ = condition: case 0: # else branch return 1 case _: # then branch return 0 ``` ### Match ```python match x = Option/none: case Option/some: y = x.value case Option/none: y = 0 ``` A pattern matching statement, the cases must be the constructor names of the matching value. It is possible to bind a variable name to the matching value. The fields of the matched constructor are bound to `matched_var.field_name`. ### Fold ```python fold x = Tree/Leaf: case Tree/Node: return x.value + x.left + x.right case Tree/Leaf: return 0 ``` A fold statement. Reduces the given value with the given match cases. It is possible to bind a variable name to the matching value. Just like in `match`, the fields are bound to `matched_var.field_name`. For fields notated with `~` in the type definition, the fold function is called implicitly. It is equivalent to the inline recursive function: ```python def fold(x: Tree(u24)) -> u24: match x: case Tree/Node: return x.value + fold(x.left) + fold(x.right) case Tree/Leaf: return 0 ... fold(Tree/Leaf) ``` ### Bend Bend can be used to create recursive data structures: ```rust bend x = 0: when x < 10: left = fork(x + 1) right = fork(x + 1) y = Tree/Node(left, right) else: y = Tree/Leaf(x) ``` Which binds a variable to the return of an inline recursive function. The function `fork` is available inside the `when` arm of the `bend` and calls it recursively. It is possible to pass multiple state variables, which can be initialized: ```python bend x = 1, y = 2 ...: when condition(x, y, ...): ... ``` When calling `fork`, the function must receive the same number of arguments as the number of state variables. It is equivalent to this inline recursive function: ```python def bend(x, y, ...): if condition(x, y, ...): ... return ... bend(x, y, ...) ... else: return ... ``` ### Open ```python p = Point { x: 1, y: 2 } open Point: p return Point { x: p.x * p.x, y: p.y * p.y } ``` Brings the inner fields of an object into scope. The original variable can still be accessed, but doing so will cause any used fields to be duplicated. It's equivalent to pattern matching on the object, with the restriction that its type must have only one constructor. ```python open Point: p ... # Equivalent to: match p: Point: ... ``` ### With block ```python with Result: x <- safe_div(2, 0) return x ``` A monadic `with` block. Where `x <- ...` performs a monadic operation. Expects `Result` to be a type defined with `type` or `object` and the function `Result/bind` to be defined. The monadic bind function should be of type `(Result a) -> (a -> Result b) -> Result b`, like this: ```python def Result/bind(res, nxt): match res: case Result/Ok: nxt = undefer(nxt) return nxt(res.value) case Result/Err: return res ``` However, the second argument, `nxt`, is actually a deferred call to the continuation, passing any free variables as arguments. Therefore, all `bind` functions must call the builtin function `undefer` before using the value of `nxt`, as in the example above. This is necessary to ensure that the continuation in recursive monadic functions stays lazy and doesn't expand infinitely. This is an example of a recursive function that would loop if passing the variable `a` to the recursive call `Result/foo(a, b)` was not deferred: ```python def Result/foo(x, y): with Result: a <- Result/Ok(1) if b: b = Result/Err(x) else: b = Result/Ok(y) b <- b return Result/foo(a, b) ``` Other statements are allowed inside the `with` block and it can both return a value at the end and bind a variable, like branching statements do. ```python # Also ok: with Result: x <- safe_div(2, 0); y = x return y ``` The name `wrap` is bound inside a `with` block as a shorthand for `Type/wrap`, and it calls the unit function of the monad, also called `pure` in some languages: ```python def Result/wrap(x): return Result/Ok(x) with Result: x <- some_operation(...) y <- some_operation(...) return wrap(x * y) ``` ### Def Creates a local function visible in the current block capturing variables: ```python def main() -> _: y = 41 x = 1 def aux_add(x): return x + y return aux_add(x) ``` ## Expressions ### Variables ```python some_var foo/bar ``` A variable can be anything matching the regex `[A-Za-z0-9_.-/]+` but with some restrictions: - It can not start with `//` - It can not contain `__` A variable is a name for some immutable expression. It is possible to rebind variables with the same name. ```python x = 1 x = x + 1 ``` Note that `-` is also used for negative numbers and as the numeric operator. Bend's grammar is greedily parsed from left to right, meaning that `x-3` always represents a name and not `x - 3` or a sequence of expressions like in `[x -3]`. ### Lambdas ```python lambda x: x lambda x, y: y λx y: x ``` Lambdas represents anonymous inline functions, it can bind a variable and has an expression as body. Using `,` is optional. ### Unscoped Lambdas and Variables ```python lambda $x: $x λ$x $y: $x ``` Like lambdas, with the exception that the variable starts with a `$` sign. Every unscoped variable in a function must have a unique name and must be used exactly once. Unscoped variables are not transformed and linearized like normal scoped variables. Read [using scopeless lambdas](/docs/using-scopeless-lambdas.md) to know more about their behavior. ### Function Call ```python callee(arg_1, arg_2, arg_n) ``` A call is written with a callee followed by a list of arguments. Arguments can be optionally separated by `,`. The effect of a function call is to substitute the callee with it's body and replace the arguments by the passed variables. The called function can be any expression and it supports partial applications. Optionally, if you call a function by its name, you can used named arguments: ```python callee(expr1, expr2, arg4 = expr3, arg3 = expr4) ``` In case named arguments are used, they must come after the positional arguments and the function must be called with exactly the number of arguments of its definition. ### Eraser ```python * eraser = * *(41 + 1) # applies 41 + 1 to `*` erasing the number and returns `*` * = 41 + 1 # erases 41 + 1 ``` The effect of an eraser is to free memory. Erasers behave like a `null`. It's impossible to compare or match eraser values. It is implicitly inserted for variables that have not been used: ```python def constant(x): return 8345 ``` ### Tuple ```python (3, 9) ``` A Tuple is surrounded by `(` `)` and should contain 2 or more elements. Elements are separated by `,`. ### Superposition ```python {1 2 3} ``` A superposition of values is defined using `{` `}` with at least 2 expressions inside. Elements can be optionally separated by `,`. Read [sups and dups](./dups-and-sups.md) to know more. ### Numbers and Infix Operations Currently, bend supports 3 types of numbers: floats, integers and unsigned integers. All of then are 24 bit sized. ```python f24 = +88.012 i24 = -42 u24 = 42 ``` Currently, We can't write operations that mix two types of number but we can explicitly convert between them. | Operation | Syntax | Supported Types | | --------------------- | -------- | ---------------- | | Addition | x + y | int, float, uint | | Subtraction | x - y | int, float, uint | | Multiplication | x \* y | int, float, uint | | Division | x / y | int, float, uint | | Remainder | x % y | int, float, uint | | Exponentiation | x \*\* y | float | | Equal | x == y | int, float, uint | | Not Equal | x != y | int, float, uint | | Less Than | x < y | int, float, uint | | Greater Than | x > y | int, float, uint | | Less Than or Equal | x <= y | int, float, uint | | Greater Than or Equal | x >= y | int, float, uint | | Bitwise And | x & y | int, uint | | Bitwise Or | x \| y | int, uint | | Bitwise Xor | x ^ y | int, uint | | Bitwise Right Shift | x >> y | uint | | Bitwise Left Shift | x << y | uint | Hexadecimal and binary floating-point literals are also supported. In these representations, each digit after the point is divided according to the base’s power of the digit's position. Specifically, for hexadecimal floating-point numbers, each place after the dot represents a fraction of 16 to the power of the digit's depth. Similarly, for binary floating-point numbers, each place after the dot represents a fraction of 2 to the power of the digit's depth. ```python 0xA.A == 10.625 0b111.111 == 7.875 ``` ### Constructor Literals Constructors are just functions. A Constructor expression is equivalent to calling a Constructor function, they have 2 syntaxes: ```python # Constructor syntax, requires all field names Type/Ctr { field1: 4, field2: 8 } # Function syntax Type/Ctr(field1 = 4, field2 = 8) Type/Ctr(4, field2 = 8) Type/Ctr(4, 8) Type/Ctr(4) # Can be partially applied if not using named arguments ``` ### Character Literal ```python 'x' ``` A Character is surrounded with `'`. Accepts unicode characters, unicode escapes in the form '\u{hex value}' and is desugared to the unicode codepoint as an `u24`. Only supports unicode codepoints up to `0xFFFFFF`. ### Symbol Literal ```python # Becomes 2146 (33 << 6 + 34) `hi` ``` A Symbol encodes a up to 4 base64 characters as a `u24` number. It is surrounded by `\``. Empty characters are interpreted as `A` which has value 0, meaning that `B` is the same as `AAAB`. ### String Literal ```python "Hello, World!" ``` A String literal is surrounded with `"`. Accepts the same values as characters literals. It is desugared to constructor calls of the built-in type String, `String/cons(head, ~tail)` and `String/nil` . ### List Literal ```python [1, 2, "three"] ``` A List literal is surrounded by `[` `]`. The elements must be separated by `,`. It is desugared to constructor calls of the built-in type List, `List/cons(head, ~tail)` and `List/nil` . ### Tree Literals ```python ![![1, 2], ![3, 4]] ``` The Tree literals `![]` and `!` are used to create values of the built-in type `Tree`. `![a b]` is equivalent to `Tree/Node(a, b)`. `!x` is equivalent to `Tree/Leaf(x)`. ### Map Literals ```python { 0: 4, `hi`: "bye", 'c': 2 + 3 } x[0] = 5 # Assigns the key 0 to the value 5 return x[0] # Gets the value of the key 0 ``` Bend has a built-in binary tree map data structure where the key is a `u24`, meaning you can use numbers, characters, and symbols as keys. ### List Comprehension ```python [x + 1 for x in list] [x + 1 for x in list if x > 2] ``` A List Comprehension generates a new list, it can be extracted in 3 parts. `[expression . iterator . condition]` Expression: The expression to be performed in the iterator element. Iterator: Binds a name to the list elements. Condition: Optional, is used to filter the list elements. It is desugared to a fold statement: ```python fold list: List/cons: if condition: List/cons(list.head, list.tail) else: list.tail List/nil: List/nil ```
# Fun Syntax ## Top-level definitions ```rust type Name = (Ctr1 arg1 arg2) | Ctr2 Name (Ctr1 sub_arg1 sub_arg2) arg3 = rule0_body Name Ctr2 arg3 = rule1_body ``` A top-level name can be anything matching the regex `[A-Za-z0-9_.-/]+`, except it can't have `__` (used for generated names) or start with `//`. ### Function Definitions A function definition is composed of a sequence of pattern matching equations. Each rule is the name of the function, a sequence of patterns and then the body. ```rust identity x = x (Bool.neg True) = False (Bool.neg False) = True MapMaybe (Some val) f = (Some (f val)) MapMaybe None f = None Pair.get (fst, snd) f = (f fst snd) ``` A rule pattern can be: - A variable. - A number. - A constructor. - A tuple. - A superposition. - A wildcard `*`. And the builtin types that desugar to one of the above: - A list (becomes a constructor). - A string (becomes a constructor). - A natural number (becomes a constructor). - A character (becomes a number). - A symbol (becomes a number); Unscoped variables can't be defined in a rule pattern. The rule body is a term, there are no statements in the Fun variant of Bend. Read [pattern matching](./pattern-matching.md) to learn about what exactly the rules for pattern matching equations are. ### Type Defines an Algebraic Data Type, it should have at least one constructor. ```rust type Tree = (Leaf value) | (Node ~left ~right) | Nil ``` `Tree` is the ADT name and it should be unique, except that it can be used once by a constructor name. Each constructor is defined by a name followed by its fields. The `~` notation describes a recursive field. The constructors inherit the name of their types and become functions (`Tree/Node` and `Tree/Leaf` in this case). ## Terms ### Variables A variable can be anything matching the regex `[A-Za-z0-9_.-/]+` but with some restrictions: - It can not start with `//` - It can not contain `__` A variable is a name for some immutable expression. It is possible to rebind variables with the same name. ```rust let x = 1 let x = (+ x 1) ``` ### Lambda ```rust @x x λx x λ(fst, snd) snd λ{x y} x ``` Lambdas represents anonymous inline functions, it can be written with `λ` or `@` followed by a pattern and a term. A tuple or duplication pattern is equivalent to a lambda followed by a `let`. ```rust λ(fst, snd) snd λa let (fst, snd) = a; snd λ{x y} (x y) λa let {x y} = a; (x y) ``` ### Unscoped Variables ```rust λ$x $x ``` Like a normal scoped variable, but starts with a `$` sign. Every unscoped variable in a function must have a unique name and must be used exactly once. They can be defined anywhere a scoped variable would be defined in a term, like in a lambda or a `let`. Unscoped variables are not transformed and linearized like normal scoped variables. Read [using scopeless lambdas](/docs/using-scopeless-lambdas.md) to know more about. ### Application ```rust (fun arg_1 arg_2 ... arg_n) ``` An application is surrounded by `(` `)`, written in lisp style. > Lambdas have a higher precedence, so `(@x x 1)` and `((@x x) 1)` means the same thing. ### Tuples ```rust (1, 2, 3) ``` A tuple is surrounded by `(` `)`, with the difference that it's elements are separated by `,`. ### Superposition ```rust {1 2 3} ``` A superposition of values is defined using `{` `}` with at least 2 terms inside. Read [sups and dups](./dups-and-sups.md) to know more. ### Let-bindings ```rust let x = (+ 1 2) x let (fst, snd, era) = (1, 2, *); (+ fst snd) let {f1 f2} = λx x; (f1 f2) let $x = (some_fn $x); * ``` > `*` is an eraser term. A let term uses a pattern, it can be: - A variable / unscoped variable. - A tuple. - A superposition. The let term will expects a binding value followed by a `next` term. Using `;` is optional. ### Use ```rust use x = (+ 2 3) (+ x x) ``` Inline copies of the declared bind, it is equivalent to this code: ```rust (+ (+ 2 3) (+ 2 3)) ``` ### Switch ```rust switch n { 0: "zero" 1: "one" _: "greater than 1" } switch x = (+ 1 1) { 0: 42; _: x-1; } ``` A switch for native numbers, it can hold a name binding if the matching term is not a variable. The cases need to be typed from `0` to a wildcard `_` in sequence. In the last case, the predecessor value is available with the name `bound_var-next_num`, where `bound_var` is the variable set by the condition and `next_num` is the expected value of the next case. For example, the above example code returns `1`, since `x-1` is bound to `(+ 1 1) - 1` and the value of `x` doesn't match any explicit case. Using `;` is optional. ### Match ```rust match opt = (Some "Bend") { Some: opt.value; None: "No name"; } ``` A pattern match expression, it can hold a name binding if the matching term is not a variable. It is possible to use a _wildcard_, a named variable or `*` as default cases. It is desugared according to the chosen encoding. Read [pattern matching](./pattern-matching.md) to know more. Using `;` is optional. ### If ```rust if condition { ...then } else { ...else } ``` A branching expression where `else` is mandatory. The condition must return a `u24` number, where 0 will run the `else` branch and any other value will return the first one. It is equivalent to this switch: ```rust switch _ = condition { 0: else _: then } ``` It is possible to make if-chains using `elif`: ```rust if condition1 { 0 } elif condition2 { 1 } elif condition3 { 2 } else { 3 } ``` ### Bend Bend can be used to create recursive data structures: ```rust main = bend x = 0 { when (< x 3): (Tree/Node (fork (+ x 1)) (fork (+ x 1))) else: (Tree/Leaf x) } ``` Which binds a variable to the return of an inline recursive function. The function `fork` is available inside the `when` arm of the `bend` and calls it recursively. It is possible to pass multiple state variables, which can be initialized: ```rust bend x = 0, y = 1 ... { when (condition x y ...): ... } ``` When calling `fork`, the function must receive the same number of arguments as the number of state variables. It is equivalent to this inline recursive function: ```rust bend x y ... = if (condition x y ...) { ... ... (bend x y ...) ... } else { ... } ``` ### Open ```rust let x = (Pair 1 2); open Pair x; (+ x.fst x.snd) ``` Brings the inner fields of an object into scope. The original variable can still be accessed, but doing so will cause any used fields to be duplicated. It's equivalent to pattern matching on the value, with the restriction that its type must have only one constructor. ```rust let x = (Pair 1 2) match x { Pair: (+ x.fst x.snd) } ``` ### With block ```rust Result/bind (Result/Ok val) nxt = ((undefer nxt) val) Result/bind err _nxt = err div a b = switch b { 0: (Result/Err "Div by 0") _: (Result/Ok (/ a b)) } rem a b = switch b { 0: (Result/Err "Mod by 0") _: (Result/Ok (% a b)) } Main = with Result { ask y = (div 3 2); ask x = (rem y 0); x } ``` Receives a type defined with `type` and expects `Result/bind` to be defined as a monadic bind function. It should be of type `(Result a) -> (a -> Result b) -> Result b`, like in the example above. However, the second argument, `nxt`, is actually a deferred call to the continuation, passing any free variables as arguments. Therefore, all `bind` functions must call the builtin function `undefer` before using the value of `nxt`, as in the example above. This is necessary to ensure that the continuation in recursive monadic functions stays lazy and doesn't expand infinitely. This is an example of a recursive function that would loop if passing the variable `a` to the recursive call `Result/foo(a, b)` was not deferred: ```python Result/foo x y = with Result { ask a = (Result/Ok 1) ask b = if b { (Result/Err x) } else { (Result/Ok y) } (Result/foo a b) } ``` Inside a `with` block, you can use `ask`, to access the continuation value of the monadic operation. ```rust ask y = (div 3 2) ask x = (rem y 0) x # Becomes (Result/bind (div 3 2) λy (Result/bind (rem y 0) λx x)) ``` It can be used to force a sequence of operations. Since the continuation receives the result through a lambda, it is only fully evaluated after something is applied to it. The name `wrap` is bound inside a `with` block as a shorthand for `Type/wrap`, the equivalent as a `pure` function in other functional languages: ```rust Result/wrap x = (Result/Ok x) with Result { ask x = (some_operation ...) ask y = (some_operation ...) (wrap (* x y)) } ``` ### Def Creates a local function visible in the current block capturing variables: ```rust main = let base = 0 def aux [] = base aux (List/Cons head tail) = (+ head (aux tail)) (aux [1, 2, 3]) ``` ### Numbers and operations Currently, bend supports 3 types of numbers: floats, integers and unsigned integers. All of then are 24 bit sized. ```rust f24 = +88.012 i24 = -42 u24 = 42 ``` Currently, the 3 number types cannot be mixed. | Operation | Syntax | Supported Types | | --------------------- | ---------- | ---------------- | | Addition | (+ x y) | int, float, uint | | Subtraction | (- x y) | int, float, uint | | Multiplication | (\* x y) | int, float, uint | | Division | (/ x y) | int, float, uint | | Remainder | (% x y) | int, float, uint | | Exponentiation | (\*\* x y) | float | | Equal | (== x y) | int, float, uint | | Not Equal | (!= x y) | int, float, uint | | Less Than | (< x y) | int, float, uint | | Greater Than | (> x y) | int, float, uint | | Less Than or Equal | (<= x y) | int, float, uint | | Greater Than or Equal | (>= x y) | int, float, uint | | Bitwise And | (& x y) | int, uint | | Bitwise Or | (\| x y) | int, uint | | Bitwise Xor | (^ x y) | int, uint | | Bitwise Right Shift | (>> x y) | uint | | Bitwise Left Shift | (<< x y) | uint | Hexadecimal and binary floating-point literals are also supported. In these representations, each digit after the point is divided according to the base’s power of the digit's position. Specifically, for hexadecimal floating-point numbers, each place after the dot represents a fraction of 16 to the negative power of the digit's depth. Similarly, for binary floating-point numbers, each place after the dot represents a fraction of 2 to the negative power of the digit's depth. ```python (== 0xA.A 10.625) (== 0b111.111 7.875) ``` ### Character Literal ```rust 'a' ``` A Character is surrounded with `'`. Accepts unicode characters, unicode escapes in the form '\u{hex value}' and is desugared to the unicode codepoint as an `u24`. Only supports unicode codepoints up to `0xFFFFFF`. ### Symbol Literal ```python # Becomes 2146 (33 << 6 + 34) `hi` ``` A Symbol encodes a up to 4 base64 characters as a `u24` number. It is surrounded by `\``. Empty characters are interpreted as `A` which has value 0, meaning that `B` is the same as `AAAB`. ### String Literal ```rust "Hello" ``` A String literal is surrounded with `"`. Accepts the same values as characters literals. The syntax above is desugared to: ``` (String.cons 'H' (String.cons 'e' (String.cons 'l' (String.cons 'l' (String.cons 'o' String.nil))))) ``` ### List Literal ```rust [1, 2, 3 4] ``` The syntax above is desugared to: ``` (List.cons 1 (List.cons 2 (List.cons 3 (List.cons 4 List.nil)))) ``` Using `,` is optional. ### Tree Literals ```python ![![1, 2], ![3, 4]] ``` The Tree literals `![]` and `!` are used to create values of the built-in type `Tree`. `![a b]` is equivalent to `Tree/Node(a, b)`. `!x` is equivalent to `Tree/Leaf(x)`. ### Nat Literal ```rust #3 ``` The syntax above is desugared to: ``` (Nat/succ (Nat/succ (Nat/succ Nat/zero))) ``` # Native HVM definitions ```py # This function causes two ports to be linked and returns *. # This can be used to interpret a lambda as an application and apply something to it for example. # It can be used like this: `let * = (link_ports @x x y)` hvm link_ports: (a (b *)) & (c a) ~ (d e) & (e b) ~ (d c) # Casts a `u24` to itself. # We can give type annotations to HVM definitions. hvm u24_to_u24 -> (u24 -> u24): ($([u24] ret) ret) ``` It's also possible to define functions using HVM syntax. This can be thought of as a way to write "HVM assembly" directly in a Bend program. You can find the reference of this syntax in the [HVM paper](https://github.com/HigherOrderCO/HVM/blob/main/paper/PAPER.pdf). This is meant for writing things that would otherwise be hard or impossible to write in normal Bend syntax. It will also ignore all term-level compiler passes and so can be useful for writing programs with exact behaviour that won't ever be changed or optimized by the compiler.
# Import Syntax ### Import Relative to the File Paths starting with `./` or `../` are imported relative to the file. ### Import Relative to the Main Folder Paths that do not start with `./` or `../` are relative to the folder of the main file. ## Syntax ### Import Specific Names from a File, or Files from a Folder ```py from path import name from path import (name1, name2) import (path/name1, path/name2) ``` ### Import All Names from a File, or All Files from a Folder ```py from path import * ``` ### Aliasing Imports ```py from path import name as alias from path import (name1 as Alias1, name2 as Alias2) import path as alias import (path/name1 as Alias1, path/name2 as Alias2) ```
# Comments ## Syntax ### Single Line Comment Use `#` to indicate a single line comment. ```py # Single line comment def main(): # return 0 ``` ### Multi Line Comment Use `#{ ... #}` to indicate a multi-line comment. Multi-line commenting should also be used to document code. Documentation for functions is meant to be written as a multiline comment right above the function. ```py #{ Expects two arguments to be passed. This function always returns the second value that was used as argument. #} def second(x: A, y: B) -> B: return y ```
# Imp Type Syntax ## Variable Any name represents a type variable. Used in generic or polymorphic type definitions. ```python # T is a type variable type Option(T): Some { value: T } None # A is a type variable def id(x: A) -> A: return x ``` ## Constructor `Ctr(...)` represents a constructor type. Used for defining custom data types or algebraic data types. Can contain other types as parameters. ```python def head(list: List(T)) -> Option(T) match list: case List/Nil: return Option/None case List/Cons: return Option/Some(list.head) ``` ## Any `Any` represents the untyped type. It accepts values of alls type and will forcefully cast any type to `Any`. Can be used for values that can't be statically typed, either because they are unknown (like in raw IO calls), because they contain untypable expressions (like unscoped variables), or because the expression cannot be typed with the current type system (like the self application `lambda x: x(x)`). ```python def main -> Any: return 24 ``` ## None `None` represents the eraser `*` or absence of a value. Often used to indicate that a function doesn't return anything. ```python def none -> None: return * ``` ## Hole `_` represents a hole type. This will let the type checker infer the most general type for an argument or return value. ```python def increment(x: _) -> _: return x + 1 ``` ## u24 `u24` represents an unsigned 24-bit integer. ```python def zero -> u24: return 0 ``` ## i24 `i24` represents a signed 24-bit integer. ```python def random_integer -> i24: return -42 ``` ## f24 `f24` represents a 24-bit floating-point number. ```python def PI -> f24: return 3.14 ``` ## Tuple `(_, _, ...)` represents a tuple type. Can contain two or more types separated by commas. ```python def make_tuple(fst: A, snd: B) -> (A, B): return (fst, snd) ``` ## Function `a -> b` represents a function type. `a` is the input type, and `b` is the output type. ```python def apply(f: A -> B, arg: A) -> B: return f(arg) ```
# Fun Type Syntax ## Variable Any name represents a type variable. Used in generic or polymorphic type definitions. ```python # T is a type variable type (Option T) = (Some T) | None # A is a type variable id : A -> A id x = x ``` ## Constructor `(Ctr ...)` represents a constructor type. Used for defining custom data types or algebraic data types. Can contain other types as parameters. ```python head : (List T) -> (Option T) head [] = Option/None head (List/Cons head _) = (Option/Some head) ``` ## Any `Any` represents the untyped type. It accepts values of alls type and will forcefully cast any type to `Any`. Can be used for values that can't be statically typed, either because they are unknown (like in raw IO calls), because they contain untypable expressions (like unscoped variables), or because the expression cannot be typed with the current type system (like the self application `λx (x x)`). ```python main : Any main = @x x ``` ## None `None` represents the eraser `*` or absence of a value. Often used to indicate that a function doesn't return anything. ```python none : None none = * ``` ## Hole `_` represents a hole type. This will let the type checker infer the most general type for an argument or return value. ```python increment : _ -> _ increment x = (+ x 1) ``` ## u24 `u24` represents an unsigned 24-bit integer. ```python zero : u24 zero = 0 ``` ## i24 `i24` represents a signed 24-bit integer. ```python random_integer : i24 random_integer = -24 ``` ## f24 `f24` represents a 24-bit floating-point number. ```python PI : f24 PI = 3.14 ``` ## Tuple `(_, _, ...)` represents a tuple type. Can contain two or more types separated by commas. ```python make_tuple : A -> B -> (A, B) make_tuple fst snd = (fst, snd) ``` ## Function `a -> b` represents a function type. `a` is the input type, and `b` is the output type. ```python apply : (A -> B) -> A -> B apply f arg = (f arg) ``` ================================================ FILE: docs/type-checking.md ================================================ # Type Checking Bend has a type checker with optional typing support based on a Hindley Milner type system. Programs can be optionally typed using the respective imp or fun type syntax. Type checking is enabled by default, but can be toggled with the `-Otype-check` and `-Ono-type-check` options. Every function can be annotated with a type for its arguments and return value. The type checker will infer the type of the function and then compare if it's compatible with the annotated type. ```python def add(x: u24, y: u24) -> u24: return x + y # Arguments or return value without annotation are considered `Any`. # They will be accepted by any function, regardless of being correct or not. def push(list: List(T), value) -> List(T): match list: case List/Nil: return List/Cons(value, List/Nil) case List/Cons: return List/Cons(list.head, push(list.tail, value)) # Error, List(T) must only receive values of type `T`. def append_num(list: List(T), num: u24) -> List(T): return List/Cons(num, list) # Error, Tree(T) can only store one type of value. def my_tree() -> _: return ![!1, !"a"] # Error, can't add a `u24` and a `f24`. # Bend doesn't have implicit type conversions. def add_float(x: u24, y: f24) -> f24: return x + y ``` Bend comes with the following builtin types: * `u24`: Unsigned 24-bit integer. * `i24`: Signed 24-bit integer. * `f24`: Floating point number. * `(T1, ..., Tn)`: Tuple with `n` elements of types `T1` to `Tn`. * `Any`: Untyped value. * `None`: Eraser `*`. * `_`: A type that will be inferred by the type checker. The prelude library also defines some basic types that are used in Bend programs: * `String`: Text represented as a sequence of Unicode characters. * `List(T)`: A list of values of type `T`. * `Tree(T)`: A binary tree with values of type `T` at the leaves. * `Map(T)`: A map from keys of type `u24` to values of type `T`. * `IO(T)`: A monadic IO type that can be used to perform IO operations. * `Result(O, E)`: Represents the result of an operation that can either succeed with an `O` or fail with an `E`. Additionally, you can define your own algebraic data types. In this case, all the type variables that occur in the constructors must be previously defined. ```python type Option(T): Some { value: T } None ``` All the constructors will be declared with the same type `TypeName(var2, var2, ...)`. ### Enabling and disabling type checking In some cases we know that dynamically our program will not do something wrong despite not being able to give it the proper type. We can disable type checking for a specific function by either removing the type annotations or by giving it the `unchecked` keyword: ```python # Error, type-checked functions can't contain an unscoped variable. def channel(x: u24) -> (u24 -> u24, u24): return (lambda $a: x, $a) # We can remove the annotations. It won't be type-checked, # but its type will be `Any -> Any`. def channel(x): return (lambda $a: x, $a) # Instead, we can use the `unchecked` keyword. # The annotated type will be considered the truth, regardless of being correct or not. def unchecked channel(x: u24) -> (u24 -> u24, u24): return (lambda $a: x, $a) ``` The opposite is also possible, we can enable type checking for an unannotated function by using the `checked` keyword before the name of the function in its declaration: ```python # Despite the inferred type being `List(T) -> List(T)`, the type checker will consider it as `Any -> Any` because it's not annotated. def checked tail(list): match list: case List/Nil: return List/Nil case List/Cons: return list.tail # Error, can't infer the type of this function, despite having type `Any`. # Not typeable by a Hindley-Milner type system. checked (scott_concat a b) = (a λh λt λcons λnil (cons h (scott_concat t b)) b ) ``` We can also disable type checking for the entire program by using the `-Ono-type-check` option. Native HVM definitions are always unchecked. ```python # This function will be given the type `a -> a`. hvm native_id -> (a -> a): (x x) ``` ### Limitations Currently, the following are not supported by the type checker: - Superpositions (`{a, b}`, the tuple type with duplication semantics, see [Dups and sups](https://github.com/HigherOrderCO/Bend/blob/main/docs/dups-and-sups.md)). - Unscoped variables and variable binds (`$a`, `let $a = ...`, see [Scopeless lambdas](https://github.com/HigherOrderCO/Bend/blob/main/docs/using-scopeless-lambdas.md)). - Expressions not typeable by a Hindley-Milner type system (e.g. self application `λx: x(x)`). Additionally, the builtin types `Number` and `Integer` can't be used directly in type annotations. They are used internally by the type checker to handle numeric expressions. ```python # The inferred type will be `Number(a) -> Number(a) -> Number(a)`. def add(x: _, y: _) -> _: return x + y # The inferred type will be `Integer(a) -> Integer(a) -> Integer(a)`. def shift(x: _, n: _) -> _: return x << n ``` ================================================ FILE: docs/using-scopeless-lambdas.md ================================================ # Using scopeless lambdas Scopeless lambdas are very powerful lambdas that are a side-effect of HVM's internal representation for lambda terms. Scopeless lambdas are lambdas that have no scope. The variables bound by them can be used outside the lambda's body. They can be created by prefixing a dollar symbol (`$`) to a lambda's variable name. ```py λ$x $x # The identity function as a scopeless lambda ``` Of course, using scopeless lambdas as a replacement for regular lambdas is kind of pointless. Their real power comes from being able to use the bound variable outside the body: ```py main = (((λ$x 1) 2), $x) # $x gets replaced by 2 and the application ((λ$x 1) 2) gets replaced by 1 # Outputs (1, 2) ``` In the imp syntax, scopeless lambdas can be written in the following way: ```py def main() -> _: # This is the equivalent code to the above example # Notice that in the imp syntax, you scopeless lambdas are written as `lambda $x: 1` instead of `λ$x 1`. f = lambda $x: 1 return (f(2), $x) ``` Take some time to think about the program above. It is valid, despite `$x` being used outside the lambda's body. However, scopeless lambdas don't bind across definitions. ```py def = $x main = (((λ$x 1) 2), def) ``` The bound variables are local to each term. ## Duplicating scopeless lambdas We have seen that the variable bound to a scopeless lambda gets set when the lambda is called. But, what happens if we never call `λ$x 1`? What will `$x` get set to then? Here is a program that does that: ```py main = let _ = λ$x 1 # Discard and erase the scopeless lambda (2, $x) # Outputs (2, *) ``` The program outputs `2` as the first item of the tuple, as expected. But the second item is `*`! What is `*`? `*` (called ERA or eraser) is a special term HVM uses when a value was erased. This is what happened to `$x`. We erased `λ$x 1` when we discarded it, which led to `$x` being erased. What happens if we call `λ$x 1` with two different values instead? Try to answer this with your knowledge of HVM. Will it throw a runtime error? Will it return something unexpected? ```py main = let f = λ$x 1 # Assign the lambda to a variable ((f 2), ((f 3), $x)) # Return a tuple of (f 2) and another tuple. # Outputs (1, (1, {2 3})) ``` What? This is even more confusing. The first two values are `1`, as expected. But what about the last term? The last term in the tuple is a **superposition** of two values. A [superposition](dups-and-sups.md) is the "other side" of a duplication. It is created here because we implicitly duplicated `f` when we used it twice, and duplicating lambdas creates superpositions. When implicitly duplicating a lambda, the order of the arguments is left to the compiler's discretion. So it's possible that depending on the context of your program, the order of the arguments on the superposition might be different than expected. If you want to make sure that your duplications come out in a specific order, you need to explicitly duplicate the lambda. ## Usage Now that we know how scopeless lambdas work, we can make programs using them. An example of a function that is usually thought as "primitive", but can be implemented using scopeless lambdas is [call/cc](http://www.madore.org/~david/computers/callcc.html) Call/cc is a function that takes a function that takes a parameter `k`. When `k` is called with an argument, `callcc` returns it. ```py # Function that discards its second argument Seq a b = a # Create a program capable of using `callcc` CC.lang = λprogram let callcc = λcallback (λ$garbage($hole) (callback λ$hole(0))); let result = (program callcc); (Seq result $garbage) Main = (CC.lang λcallcc # This code calls `callcc`, then calls `k` to fill the hole with `42`. This means that the call to callcc returns `42`, and the program returns `52`. (+ (k 42) 1729) is garbage and is erased. (+ 10 (callcc λk(+ (k 42) 1729))) ) ``` ================================================ FILE: docs/writing-fusing-functions.md ================================================ # Writing fusing functions ## Church encoding Church Encoding is a way to encode common datatypes as λ-calculus terms. For example, here is a [Church-encoded](https://en.wikipedia.org/wiki/Church_encoding) boolean type in HVM ```py true = λt λf t false = λt λf f ``` Matching on values of this representation is simply calling the boolean value with what the function should return if the boolean is true and if the boolean is false. ```py if boolean case_true case_false = (boolean case_true case_false) main = (if true 42 37) # Outputs 42 # Or alternatively: # if boolean = boolean # Each boolean is represented by its own matching function # so (true 42 37) will do the same thing. ``` This is how a `Not` function that acts on this encoding can be defined: ```py not = λboolean (boolean false true) main = (not true) # Outputs λtλf f. main = (not false) # Outputs λtλf t. ``` If the boolean is `true`, then the function will return `false`. If it is `false`, it will return `true`. ## Self-application What happens if we self-compose the `not` function? It is a well known fact that`(not (not x)) == x`, so we should expect something that behaves like the identity function. ```py main = λx (not (not x)) # Output: # λa (a λ* λb b λc λ* c λ* λd d λe λ* e) ``` The self-application of `not` outputs a large term. Testing will show that the term does indeed behave like an identity function. However, since the self-application of `not` is larger than `not` itself, if we self-compose this function many times, our program will get really slow and eat up a lot of memory, despite all functions being equivalent to the identity function: ```py main = λx (not (not x)) # Long main = λx (not (not (not (not x)))) # Longer main = λx (not (not (not (not (not (not (not (not x)))))))) # Longer # etc... ``` The self-application of not a large number of times, such as 65536 or 4294967296, will be large enough to slow down our computer by a significant amount. Luckily, there's a trick we can do to make the self-application of `not` much shorter. The trick is to rewrite `not` in another way that makes the self-composition of `not` much smaller. This trick is called "fusing". Here is how it's done. ### Fusing functions Let's first take our initial `not` implementation. ```py not = λboolean (boolean false true) ``` We begin by replacing `false` and `true` by their values. ```py not = λboolean (boolean λtλf(f) λtλf(t)) ``` After doing this, it's easy to notice that there's something that both terms have in common. Both of them are lambdas that take in two arguments. We can **lift** the lambda arguments up and make them **shared** between both cases. ```py not = λboolean λt λf (boolean f t) ``` Let's see how the self-application of `not` gets reduced now. Each line will be a step in the reduction. ```py main = λx (not (not x)) main = λx (not (λbooleanλtλf (boolean f t) x)) main = λx (not (λtλf (boolean x f t))) main = λx (λboolean1λt1λf1 (boolean1 f1 t1) (λtλf (boolean x f t))) main = λxλt1λf1 (λtλf (x f t) f1 t1) main = λxλt1λf1 (λf (x f f1) t1)) main = λxλt1λf1 (x t1 f1) ``` Wow! Simply by replacing lambda arguments with the values applied to them, we were able to make `(not (not x))` not grow in size. This is what fusing means, and it's a really powerful tool to make programs faster. Fusing isn't only for Church-encoded `not`. Fusing can be done anywhere where efficient composition is important. What we simply have to do is "lift" lambdas up, and make the arguments "shared" between all cases. ## Preventing duplication Something else that is important when writing fusing functions is linearizing variables to prevent useless duplication. Consider the [scott-encoded](https://crypto.stanford.edu/~blynn/compiler/scott.html) type `Nat`: ```py zero = λs λz z # 0 as a scott-encoded number succ = λpred λs λz (s pred) # Creates a Scott number out of its predecessor two = (succ (succ zero)) # λs λz (s λs λz (s λs λz z)) ``` We can write an addition function for this type, that adds two numbers ```py add = λa λb let case_succ = λa_pred (succ (add a_pred b)) # If a = p+1, then return (p+b)+1 let case_zero = b # If the `a = 0`, return `b` (a case_succ case_zero) ``` This code seems fine, but it has a problem that makes it suboptimal. There is an implicit [duplication](dups-and-sups.md) here: ```rs add = λa λb let {b1 b2} = b; let case_succ = λa_pred (succ (add a_pred b0)) let case_zero = b1 (a case_succ case_zero) ``` However, only one of the two duplicated values is ever used. The other one is discarded. This means that this duplication is completely useless! It makes this function suboptimal. In fact, as of commit `ebd469`, it will hang HVM, because it's recursive and HVM2 is eager. The correct way to define this function is this, which pushes the duplicating lambdas down, and removes the duplication: ```rs fusing_add = λa let case_succ = λa_pred λb (succ (fusing_add a_pred b)) let case_zero = λb b (a case_succ case_zero) ``` This function is fusing on `a`, which means that `λx (fusing_add two x)` will have a small normal form (but `λx (fusing_add x two)` won't). Broadly speaking, a good rule of thumb in HVM is **push linear lambdas to the top and duplicating lambdas to the bottom**. ## Example To show the power of fusing, here is a program that self-composes `fusing_not` 2^24 times and prints the result. Currently hvm is not able to handle operations between church numbers so we explicitly convert the native number to a church number in this example (which is very slow). This program uses [native numbers, which are described here](native-numbers.md). ```py true = λt λf t false = λt λf f not = λboolean (boolean false true) fusing_not = λboolean λt λf (boolean f t) # Creates a Church numeral out of a native number to_church n = switch n { 0: λf λx x _: λf λx (f (to_church n-1 f x)) } main = ((to_church 0xFFFFFF) fusing_not) # try replacing this by regular not. Will it still work? ``` Here is the program's output: ```bash $ bend norm -s fuse_magic.hvm Result: λa λb λc (a c b) - ITRS: 285212661 - TIME: 5.67s - MIPS: 50.28 ``` A lot of rewrites, but most of those are just to create the church number. ================================================ FILE: examples/bitonic_sort.bend ================================================ # Implements bitonic sort on a list of numbers encoded as a tree of pairs. # https://en.wikipedia.org/wiki/Bitonic_sorter # Because we can't know when a tree of pairs is a leaf or a node, we pass the depth everywhere. # Generates a tree of pairs with depth 'd' with numbers from 2^d to 0 at the leaves def gen(d): bend d, x=0: when d: return (fork(d - 1, x * 2 + 1), fork(d - 1, x * 2)) else: return x # Adds all the numbers in a tree of pairs of depth 'd' def sum(d, t): switch d: case 0: return t case _: (t.a, t.b) = t return sum(d-1, t.a) + sum(d-1, t.b) # Conditionally swaps the values of a pair def swap(s, a, b): if s: return (b,a) else: return (a,b) def warp(d, s, a, b): switch d: case 0: return swap(s + (a > b), a, b) case _: (a.a,a.b) = a (b.a,b.b) = b (A.a,A.b) = warp(d-1, s, a.a, b.a) (B.a,B.b) = warp(d-1, s, a.b, b.b) return ((A.a,B.a),(A.b,B.b)) def flow(d, s, t): switch d: case 0: return t case _: (t.a, t.b) = t return down(d, s, warp(d-1, s, t.a, t.b)) def down(d,s,t): switch d: case 0: return t case _: (t.a, t.b) = t return (flow(d-1, s, t.a), flow(d-1, s, t.b)) # Bitonic sort def sort(d, s, t): switch d: case 0: return t case _: (t.a, t.b) = t return flow(d, s, (sort(d-1, 0, t.a), sort(d-1, 1, t.b))) def main: # Generate a reverse sorted tree of numbers, sort them and then add them up return sum(18, sort(18, 0, gen(18))) ================================================ FILE: examples/bubble_sort.bend ================================================ # Sorts a list def sort(xs: List(u24)) -> List(u24): match xs: case List/Nil: return List/Nil case List/Cons: return insert(xs.head, sort(xs.tail)) def insert(v: u24, xs: List(u24)) -> List(u24): match xs: case List/Nil: return List/Cons(v, List/Nil) case List/Cons: return swap_gt(v, xs.head, xs.tail) def swap_gt(v: u24, x: u24, xs: List(u24)) -> List(u24): if x > v: return List/Cons(v, List/Cons(x, xs)) else: return List/Cons(x, insert(v, xs)) # Generates a list of 'n' random u24 numbers using xorshift def rnd(n: u24) -> List(u24): bend n, state=1: when n != 0: state = state ^ (state << 13) state = state ^ (state >> 17) state = state ^ (state << 5) return List/Cons(state % 100, fork(n - 1, state)) else: return List/Nil # Sums a list of u24 numbers def sum(xs: List(u24)) -> u24: fold xs: case List/Nil: return 0 case List/Cons: return xs.head + xs.tail def main() -> u24: n = 100 return sum(sort(rnd(n))) ================================================ FILE: examples/callcc.bend ================================================ # This program is an example that shows how scopeless lambdas can be used. Seq (a: A) (b: B) : A = a # Create a program capable of using `callcc` unchecked CC.lang : ((((a -> b) -> b) -> c) -> c) -> d = λprogram let callcc = λcallback (λ$garbage($hole) (callback λ$hole(0))); let result = (program callcc); let garbage = $garbage; # Discard `$garbage`, which is the value returned by `callback` (Seq result garbage) main: u24 = (CC.lang λcallcc # This code calls `callcc`, then calls `k` to fill the hole with `42`. # This means that the call to callcc returns `42`, and the program returns `52` (+ 10 (callcc λk(+ (k 42) 1729))) ) ================================================ FILE: examples/example_fun.bend ================================================ # Example of some things you can do with the 'fun' syntax # Define functions like this: # By default they accept and return any type (Def1) = ((λa a) (λb b)) # You can call a definition by just referencing its name. # It will be substituted in place of the reference. (Def2) = ((λa a) Def1) # Definitions and variables can have names in upper and lower case and # contain numbers, '.', '-', '_' and '/'. # Names defined in a more inner position shadow names in an outer position. (def3) = ((λDef1 Def1) (λx λx x)) # You can annotate a function with the expected types and Bend will check them. # The parentheses on the left side of the definition are optional. const (a: A) (b: B) : A = a # There are three types of native numbers available: u24, i24 and f24. # u24: Unsigned 24-bit integers # i24: Signed 24-bit integers # f24: Floating point numbers with 24-bit precision (unsigneds (x1: u24) (x2: u24)) : u24 = (* (+ x1 1) (/ (- x2 2) 1)) # '+' or '-' are mandatory for i24. (signeds (x1: i24) (x2: i24)) : i24 = (* (+ x1 +1) (/ (- x2 -2) +1)) # The '.' is mandatory for f24. (floats (x1: f24) (x2: f24)) : f24 = (* (+ x1 1.0) (/ (- x2 -2.0) +1.0)) # Numeric operations are only meaningful on native numbers. # You can force the compiler to do it anyway by using untyped values. id = λx x # 'id' wasn't given a type so it's inferred as 'Any'. bad_nums : Any = (+ id 1) # You can use numbers on the native match expression # The `+` arm binds the `scrutinee`-1 variable to the value of the number -1 (Num.pred) = λn switch n { 0: 0 _: n-1 } # Write new data types like this type Option = (Some val) | None type Bool = True | False # You can have pattern matching on definitions # Use `*` to ignore a pattern (Option.unwrap_or (Option/Some val) *) = val (Option.unwrap_or Option/None or) = or (Bool.or Bool/True *) = Bool/True (Bool.or * Bool/True) = Bool/True (Bool.or * *) = Bool/False # Or using a match expression (Bool.not) = λbool match bool { Bool/True: Bool/False Bool/False: Bool/True } # Data types can store values type Boxed T = (Box (val: T)) # Types with only one constructor can be destructured using `open`, # a single matching definition or a 'match'. (Box.map (Boxed/Box val) f) = (Boxed/Box (f val)) (Box.unbox (box: (Boxed T))): T = open Boxed box; box.val # Use tuples to store two values together without needing to create a new data type (Tuple.new fst snd) = let pair = (fst, snd) pair # Then you can destructure it inside the definition or using `let` (Tuple.fst (fst, snd)) = fst (Tuple.snd) = λpair let (fst, snd) = pair snd # You can give type annotations to type definitions as well. # The recursive fields should be annotated with a '~'. type ListList T = (Cons (head: (List T)) ~(tail: (ListList T))) | Nil # Bend functions usually center around recursion sum (List/Nil) = 0 sum (List/Cons x xs) = (+ x (sum xs)) sum_list (ListList/Nil) = List/Nil sum_list (ListList/Cons x xs) = (List/Cons (sum x) (sum_list xs)) # To create local recursive functions that consume a recursive type, you can use 'fold'. sum_list2 ll = fold ll { # The fold is implicitly called for fields marked with '~' in their definition. # In this case, 'll.tail' is replaced with a recursive call to the fold. ListList/Cons: (List/Cons (sum ll.head) ll.tail) ListList/Nil: List/Nil } # To do the opposite and create a recursive structure, you can use 'bend'. # 'bend' can be seen as a tree-like generalization of a while loop. new_list = bend x = 0 { when (< x 10): # 'fork' calls the bend recursively with the provided values. (List/Cons x (fork (+ x 1))) else: List/Nil } # To make programs that are more parallelizable, you generally want to # avoid lists and use tree-like structures with multiple recursion instead. sum_nums from to = if (< from to) { (+ (sum_nums from (/ 2 (+ from to))) (sum_nums (+ 1 (/ 2 (+ from to))) to)) } else { from } # Internally, each variable is only used once. If you use a variable # is used more than once, the compiler will insert duplications for you. # # You can also write them manually with 'let {a b} = ...', but then # your function needs to be unchecked, either by not annotating it # with types or by marking it as unchecked. unchecked (def4) = λz let {z1 z2} = z; (z1 ((λx (x x x x x)) z2)) # Duplicating a term that duplicates a variable is not allowed and will break the program. map f (List/Cons x xs) = (List/Cons (f x) (map f xs)) # 'f' is duplicated here map f (List/Nil) = List/Nil # 'map' duplicated the lambda which duplicates 'a'. # Although this is well defined, it does not produce a sound lambda-calculus result. VeryBad (a: u24) (xs: (List u24)) : (List u24) = (map λ x (+ (* a x) a) # 'a' is duplicated here [1, 2, 3, 4, 5]) # All files must have a main definition to run. # You can execute a program in Bend with "bend run " # Other options are "check" to just see if the file is well formed # and "gen-hvm" to output hvm code. (main) = let tup = (Tuple.new Option/None (Num.pred 5)) let fst = (Tuple.fst tup) let snd = (Tuple.snd tup) let box = (Boxed/Box fst) let map = (Box.map box Option.unwrap_or) let unboxed = ((Box.unbox map) snd) (unsigneds 3 unboxed) ================================================ FILE: examples/fib.bend ================================================ # Program to calculate fibonacci numbers. # Calculates fibonacci numbers recursively. # Although branching recursion is usually a good idea to parallelize, # it makes this code run in exponential time. def fib_recursive(n: u24) -> u24: switch n: case 0: return 0 case 1: return 1 case _: return fib_recursive(n-2) + fib_recursive(n-2 + 1) # Calculates fibonacci numbers iteratively (tail-recursively). # This function is inherently sequential, but runs in linear time. def fib_iterative(n: u24) -> u24: bend a=0, b=1, n: when n != 0: return fork(b, a + b, n - 1) else: return a def main() -> u24: # With the iterative version, we can calculate large fibonacci numbers # While with the recursive version, we will quickly run out of memory. # Note that for numbers larger than 36 the result will overflow the space of the 24-bit integer. # But we can run any number we want reasonably fast. return fib_iterative(30) # With the recursive version we create a tree with exponential size. # For numbers larger than ~45, this will hit the maximum HVM memory and crash. # Try uncommenting and running this line and compare the execution time. #return fib_recursive(20) ================================================ FILE: examples/fusing_add.bend ================================================ # Example of fusing functions with Scott-encoded numbers. zero = λs λz z succ = λpred λs λz (s pred) # Creates a Scott number out of its predecessor two = (succ (succ zero)) # λs λz (s λs λz (s λs λz z)) fusing_add = λa let case_succ = λa_pred λb (succ (fusing_add a_pred b)) let case_zero = λb b (a case_succ case_zero) # (fusing_add two) creates a fused function that efficiently adds two to whatever you pass to it. Main = λx (fusing_add two x) ================================================ FILE: examples/fusing_not.bend ================================================ # Example of a boolean 'not' function that fuses inifinitely through composition.. true : a -> b -> a = λt λf t false : a -> b -> b = λt λf f not : ((a -> b -> b) -> (c -> d -> c) -> e) -> e = λboolean (boolean false true) fusing_not : (b -> a -> c) -> a -> b -> c = λboolean λt λf (boolean f t) # Creates a Church numeral out of a native number to_church (n: u24) : (a -> a) -> a -> a = switch n { 0: λf λx x _: λf λx (f (to_church n-1 f x)) } main: _ = # Self-composes `not` 2^23-1 times and prints the result. ((to_church 0x7FFFF) fusing_not) # try replacing 'fusing_not' by 'not'. Will it still work? ================================================ FILE: examples/gen_tree.bend ================================================ # Generates a tree with numbers in the nodes using 'bend' type MyTree(t): Node { val: t, ~left: MyTree(t), ~right: MyTree(t) } Leaf def tree_gen(n: u24, x: u24) -> MyTree(u24): bend n, x: when n != 0: return MyTree/Node(x, fork(n - 1, x*2+1), fork(n - 1, x*2+2)) else: return MyTree/Leaf def main -> MyTree(u24): depth = 4 first_val = 1 return tree_gen(depth, first_val) ================================================ FILE: examples/hello_world.bend ================================================ def main() -> IO(u24): with IO: * <- IO/print("Hello, world!\n") return wrap(0) ================================================ FILE: examples/insertion_sort.bend ================================================ def insertion_sort(xs: List(u24)) -> List(u24): match xs: case List/Nil: return List/Nil case List/Cons: return insertion_sort.insert(xs.head, insertion_sort(xs.tail)) # Inserts a value into a partially sorted list def insertion_sort.insert(v: u24, xs: List(u24)) -> List(u24): match xs: case List/Nil: return List/Cons(v, List/Nil) case List/Cons: return insert_aux(v > xs.head, v, xs.head, xs.tail) def insert_aux(n: u24, v: u24, x: u24, xs: List(u24)) -> List(u24): if n == 0: return List/Cons(v, List/Cons(x, xs)) else: return List/Cons(x, insertion_sort.insert(v, xs)) # Generates a list of random numbers def rnd(n: u24) -> List(u24): if n == 0: return List/Nil else: return List/Cons(random(10000 - n), rnd(n - 1)) # Generates a pseudo-random number (not very good) def random(n: u24) -> u24: if n == 0: return 0 else: return (random(n - 1) * 16 + 101387) % 429453 def main() -> List(u24): return insertion_sort(rnd(10)) ================================================ FILE: examples/list.bend ================================================ ############################## # Author: Ematth, 2024 ############################## ### Singly-Linked List Type Definition: ### # The List type is builtin, so we don't need to declare it. # But this is how it's defined in the builtins file. # type List: # Nil # Cons { head, ~tail } ########################################### # List clear: # clears all elements from list l. This is equivalent to initializing an empty list. clear : (List t) -> (List t) = @l [] # List concat: # combines two lists (l1, l2) from left to right. concat : (List t) -> (List t) -> (List t) = @l1 @l2 match l1 { List/Cons: (List/Cons l1.head (concat l1.tail l2)) List/Nil: l2 } # List add_front: # adds an element e to the front of list l. add_front : (List t) -> t -> (List t) = @l @e match l { List/Cons: (List/Cons e l) List/Nil: (List/Cons e List/Nil) } # List append (add_back): # adds an element e to the back of list l. append : (List t) -> t -> (List t) = @l @e (concat l (List/Cons e List/Nil)) # list sum: # returns the sum of all items in the list. sum : (List u24) -> u24 = @l match l { List/Cons: (+ l.head (sum l.tail)) List/Nil: 0 } # List reverse: # reverses the order of elements in list l. reverse.aux : (List t) -> (List t) -> (List t) = @acc @l match l { List/Nil: acc List/Cons: (reverse.aux (List/Cons l.head acc) l.tail) } reverse : (List t) -> (List t) = @l (reverse.aux [] l) # List length: # returns the number of elements in list l. len : (List t) -> u24 = @l match l { List/Nil: 0 List/Cons: (+ 1 (len l.tail)) } # List count: # returns the number of instances of some number n in list l. count.aux : u24 -> (List u24) -> u24 -> u24 = @acc @l @n match l { List/Nil: acc List/Cons: let acc = if (== l.head n) { (+ acc 1) } else { acc } (count.aux acc l.tail n) } count = @l @n (count.aux 0 l n) # List index: # returns the value of a specific list index i, or * if the index doesn't exist. index : (List t) -> u24 -> (Result t None) = @l @i match l { List/Cons: switch i { 0: (Result/Ok l.head) _: (index l.tail (i-1)) } List/Nil: (Result/Err *) } # List head: # returns the first item in the list, or [] if the list is empty. head : (List t) -> (Result t None) = @l match l { List/Cons: (Result/Ok l.head) List/Nil : (Result/Err *) } # List tail: # returns the list whithout the first item, or [] if the list is empty. tail : (List t) -> (List t) = @l match l { List/Cons: l.tail List/Nil: [] } # List equals: # Compares the elements in two lists and returns 1 if they're equal, and 0 otherwise. # The function cmp compares two values and returns 1 if they're equal, and 0 otherwise. equals (xs: (List a)) (ys: (List b)) (cmp: a -> b -> u24) : u24 equals (List/Cons x xs) (List/Cons y ys) cmp = if (cmp x y) { (equals xs ys cmp) } else { 0 } equals (List/Cons x xs) List/Nil cmp = 0 equals List/Nil (List/Cons y ys) cmp = 0 equals List/Nil List/Nil cmp = 1 # List pop_front: # removes and discards the first item of list l. # The new list is returned, or [] if the list is empty. pop_front : (List t) -> (List t) = @l match l { List/Cons: l.tail List/Nil: [] } # List pop_back: # removes and discards the the last item of list l. pop_back : (List t) -> (List t) pop_back (List/Nil) = List/Nil pop_back (List/Cons x List/Nil) = List/Nil pop_back (List/Cons head tail) = (List/Cons head (pop_back tail)) # List remove: # removes the first occurrence of element e from list l. remove : (List u24) -> u24 -> (List u24) = @l @s match l { List/Cons: if (== l.head s) { l.tail } else { (List/Cons l.head (remove l.tail s)) } List/Nil: List/Nil } # List split: # splits list l into two lists (l1, l2) at index i. # the second list takes the element at index i during the split. split : (List t) -> u24 -> ((List t), (List t)) = @l @i (split.aux [] l i) split.aux : (List t) -> (List t) -> u24 -> ((List t), (List t)) = @acc @l @i match l { List/Cons: switch i { 0: (acc, l) _: (split.aux (append acc l.head) l.tail i-1) } List/Nil: (acc, []) } ################################# def main: return head([5, 4, 3, 2, 1]) # return sum([1, 2, 3]) # return split([1, 2, 3, 4, 5, 6, 7], 3) # return remove([1, 2, 1, 3], 1) # return pop_back([1, 2, 3, 4]) # return pop_front([1, 2, 3]) # return index([5, 3, 6, 8, 2], 0) # return clear([0, 2, 3]) # return count([1, 2, 3, 3, 3, 4, 4, 5, 3, 1000], 4) # return len([1, 2, 3, 4, 4, 4]) # return reverse([1, 2, 3, 4, 5]) # return append([1, 2], 3) # return add_front([2, 3], 1) # return concat([1, 2], [3, 4]) ================================================ FILE: examples/parallel_and.bend ================================================ # This program allocates a tree with True at the leaves then parallel ANDs them. type Bool: True False def and(a: Bool, b: Bool) -> Bool: match a: case Bool/True: return b case Bool/False: return Bool/False # Trees of tuples are not typeable def all(tree: Tree(Bool)) -> Bool: fold tree: case Tree/Node: return and(tree.left, tree.right) case Tree/Leaf: return tree.value def gen(n: u24) -> Tree(Bool): switch n: case 0: return Tree/Leaf(Bool/True) case _: return Tree/Node { left: gen(n-1), right: gen(n-1) } def main() -> Bool: return all(gen(8)) ================================================ FILE: examples/parallel_sum.bend ================================================ # A very simple example of a massively parallel program # Creates a tree with numbers and then sums all values in parallel # a binary tree type MyTree(t): Node { val: t, ~left: MyTree(t), ~right: MyTree(t) } Leaf # sums all values in a tree def sum(tree: MyTree(u24)) -> u24: fold tree: case MyTree/Node: return tree.val + tree.left + tree.right case MyTree/Leaf: return 0 # generates a binary tree of given depth def gen(depth: u24) -> MyTree(u24): bend height=0, val = 1: when height < depth: tree = MyTree/Node { val: val, left: fork(height+1, 2*val), right: fork(height+1, 2*val+1) } else: tree = MyTree/Leaf return tree # returns the sum of [1 .. 2^16), truncated to 24 bits def main() -> u24: return sum(gen(16)) ================================================ FILE: examples/queue.bend ================================================ # A cool trick involving unscoped lambdas # Implements constant-time queues with just lambdas # Qnew : Queue a Qnew: _ = λx x # Qadd : a -> Queue a -> Queue a Qadd: _ = λx λq λk (q λc (c x k)) # Qrem : Queue a -> Pair a (Queue a) Qrem = λq (q $k λx λxs λp(p x λ$k xs)) # Output: [1, 2, 3] main: (List u24) = let q = Qnew let q = (Qadd 1 q) let q = (Qadd 2 q) let q = (Qadd 3 q) ((Qrem q) λv0 λq ((Qrem q) λv1 λq ((Qrem q) λv2 λq [1, 2, 3]))) ================================================ FILE: examples/quick_sort.bend ================================================ type MyTree t = Leaf | (Node ~(lft: (MyTree t)) (val: t) ~(rgt: (MyTree t))) # Parallel QuickSort (Sort) : (List u24) -> (MyTree u24) (Sort List/Nil) = MyTree/Leaf (Sort (List/Cons head tail)) = let (min, max) = (Part head tail) let lft = (Sort min) let rgt = (Sort max) (MyTree/Node lft head rgt) # Partitions a list in two halves, less-than-p and greater-than-p (Part) : u24 -> (List u24) -> ((List u24), (List u24)) (Part p List/Nil) = (List/Nil, List/Nil) (Part p (List/Cons head tail)) = (Push (> head p) head (Part p tail)) # Pushes a value to the first or second list of a pair (Push) : u24 -> u24 -> ((List u24), (List u24)) -> ((List u24), (List u24)) (Push 0 x (min, max)) = ((List/Cons x min), max) (Push _ x (min, max)) = (min, (List/Cons x max)) # Generates a random list with xorshift (Rnd) : u24 -> (u24) -> (List u24) (Rnd 0 state) = List/Nil (Rnd n state) = let state = (^ state (<< state 13)) let state = (^ state (>> state 17)) let state = (^ state (<< state 5)) (List/Cons state (Rnd (- n 1) state)) # Sums all elements in a concatenation tree (Sum) : (MyTree u24) -> u24 (Sum MyTree/Leaf) = 0 (Sum (MyTree/Node lft val rgt)) = (+ val (+ (Sum lft) (Sum rgt))) # Sorts and sums n random numbers (Main) : u24 = (Sum (Sort (Rnd 0x100 1))) # Use an argument from cli # (Main n) = (Sum (Sort (Rnd (<< 1 n) 1))) ================================================ FILE: examples/radix_sort.bend ================================================ type MyMap: Free Used Both { ~a: MyMap, ~b: MyMap } type Arr(t): Null Leaf { a: t } Node { ~a: Arr(t), ~b: Arr(t) } def swap(s: u24, a: MyMap, b: MyMap) -> MyMap: switch s: case 0: return MyMap/Both{ a: a, b: b } case _: return MyMap/Both{ a: b, b: a } def sort(t: Arr(u24)) -> Arr(u24): return to_arr(0, to_map(t)) def to_map(t: Arr(u24)) -> MyMap: match t: case Arr/Null: return MyMap/Free case Arr/Leaf: return radix(t.a) case Arr/Node: return merge(to_map(t.a), to_map(t.b)) def to_arr(x: u24, m: MyMap) -> Arr(u24): match m: case MyMap/Free: return Arr/Null case MyMap/Used: return Arr/Leaf{ a: x } case MyMap/Both: return Arr/Node{ a: to_arr(x * 2, m.a), b: to_arr(x * 2 + 1, m.b) } def merge(a: MyMap, b: MyMap) -> MyMap: match a: case MyMap/Free: return b case MyMap/Used: return MyMap/Used case MyMap/Both: match b: case MyMap/Free: return a case MyMap/Used: return MyMap/Used case MyMap/Both: return MyMap/Both{ a: merge(a.a, b.a), b: merge(a.b, b.b) } def radix(n: u24) -> MyMap: r = MyMap/Used r = swap(n & 1, r, MyMap/Free) r = swap(n & 2, r, MyMap/Free) r = swap(n & 4, r, MyMap/Free) r = swap(n & 8, r, MyMap/Free) r = swap(n & 16, r, MyMap/Free) r = swap(n & 32, r, MyMap/Free) r = swap(n & 64, r, MyMap/Free) r = swap(n & 128, r, MyMap/Free) r = swap(n & 256, r, MyMap/Free) r = swap(n & 512, r, MyMap/Free) return radix2(n, r) # At the moment, we need to manually break very large functions into smaller ones # if we want to run this program on the GPU. # In a future version of Bend, we will be able to do this automatically. def radix2(n: u24, r: MyMap) -> MyMap: r = swap(n & 1024, r, MyMap/Free) r = swap(n & 2048, r, MyMap/Free) r = swap(n & 4096, r, MyMap/Free) r = swap(n & 8192, r, MyMap/Free) r = swap(n & 16384, r, MyMap/Free) r = swap(n & 32768, r, MyMap/Free) r = swap(n & 65536, r, MyMap/Free) r = swap(n & 131072, r, MyMap/Free) r = swap(n & 262144, r, MyMap/Free) r = swap(n & 524288, r, MyMap/Free) return radix3(n, r) def radix3(n: u24, r: MyMap) -> MyMap: r = swap(n & 1048576, r, MyMap/Free) r = swap(n & 2097152, r, MyMap/Free) r = swap(n & 4194304, r, MyMap/Free) r = swap(n & 8388608, r, MyMap/Free) return r def reverse(t: Arr(u24)) -> Arr(u24): match t: case Arr/Null: return Arr/Null case Arr/Leaf: return t case Arr/Node: return Arr/Node{ a: reverse(t.b), b: reverse(t.a) } def sum(t: Arr(u24)) -> u24: match t: case Arr/Null: return 0 case Arr/Leaf: return t.a case Arr/Node: return sum(t.a) + sum(t.b) def gen(n: u24) -> Arr(u24): return gen_go(n, 0) def gen_go(n: u24, x: u24) -> Arr(u24): switch n: case 0: return Arr/Leaf{ a: x } case _: a = x * 2 b = x * 2 + 1 return Arr/Node{ a: gen_go(n-1, a), b: gen_go(n-1, b) } Main: u24 = (sum (sort(reverse(gen 4)))) ================================================ FILE: justfile ================================================ # To use this, first run `cargo install just` # Then run the install subcommand: `just install` # Running `just` is equivalent to running `just all` because it's the first command export CARGO_TERM_COLOR := "always" all: rustup-show check fmt clippy test sort audit rustup-show: rustup show check: cargo check --all-targets fmt: cargo fmt --all -- --check clippy: cargo clippy --all-targets test: cargo insta test --workspace sort: cargo sort --check --workspace audit: cargo audit install: cargo install --locked cargo-sort cargo-audit ================================================ FILE: src/diagnostics.rs ================================================ use TSPL::ParseError; use crate::fun::{display::DisplayFn, Name, Source}; use std::{ collections::BTreeMap, fmt::{Display, Formatter}, ops::Range, }; pub const ERR_INDENT_SIZE: usize = 2; #[derive(Debug, Clone, Default)] pub struct Diagnostics { pub diagnostics: BTreeMap>, pub config: DiagnosticsConfig, } #[derive(Debug, Clone, Copy)] pub struct DiagnosticsConfig { pub verbose: bool, pub irrefutable_match: Severity, pub redundant_match: Severity, pub unreachable_match: Severity, pub unused_definition: Severity, pub repeated_bind: Severity, pub recursion_cycle: Severity, pub missing_main: Severity, pub import_shadow: Severity, } #[derive(Debug, Clone)] pub struct Diagnostic { pub message: String, pub severity: Severity, pub source: Source, } #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] pub enum DiagnosticOrigin { /// An error when parsing source code. Parsing, /// An error from the relationship between multiple top-level definitions. Book, /// An error in a function definition. Function(Name), /// An error in a compiled inet. Inet(String), /// An error during readback of hvm-core run results. Readback, } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] pub enum Severity { Allow, Warning, Error, } #[derive(Debug, Clone, Copy)] pub enum WarningType { IrrefutableMatch, RedundantMatch, UnreachableMatch, UnusedDefinition, RepeatedBind, RecursionCycle, MissingMain, ImportShadow, } impl Diagnostics { pub fn new(config: DiagnosticsConfig) -> Self { Self { diagnostics: Default::default(), config } } pub fn add_parsing_error(&mut self, err: impl std::fmt::Display, source: Source) { self.add_diagnostic(err, Severity::Error, DiagnosticOrigin::Parsing, source); } pub fn add_book_error(&mut self, err: impl std::fmt::Display) { self.add_diagnostic(err, Severity::Error, DiagnosticOrigin::Book, Default::default()); } pub fn add_function_error(&mut self, err: impl std::fmt::Display, name: Name, source: Source) { self.add_diagnostic( err, Severity::Error, DiagnosticOrigin::Function(name.def_name_from_generated()), source, ); } pub fn add_inet_error(&mut self, err: impl std::fmt::Display, def_name: String) { self.add_diagnostic(err, Severity::Error, DiagnosticOrigin::Inet(def_name), Default::default()); } pub fn add_function_warning( &mut self, warn: impl std::fmt::Display, warn_type: WarningType, def_name: Name, source: Source, ) { let severity = self.config.warning_severity(warn_type); self.add_diagnostic( warn, severity, DiagnosticOrigin::Function(def_name.def_name_from_generated()), source, ); } pub fn add_book_warning(&mut self, warn: impl std::fmt::Display, warn_type: WarningType) { let severity = self.config.warning_severity(warn_type); self.add_diagnostic(warn, severity, DiagnosticOrigin::Book, Default::default()); } pub fn add_diagnostic( &mut self, msg: impl std::fmt::Display, severity: Severity, orig: DiagnosticOrigin, source: Source, ) { let diag = Diagnostic { message: msg.to_string(), severity, source }; self.diagnostics.entry(orig).or_default().push(diag) } pub fn take_rule_err( &mut self, result: Result, def_name: Name, ) -> Option { match result { Ok(t) => Some(t), Err(e) => { self.add_function_error(e, def_name, Default::default()); None } } } pub fn take_inet_err( &mut self, result: Result, def_name: String, ) -> Option { match result { Ok(t) => Some(t), Err(e) => { self.add_inet_error(e, def_name); None } } } pub fn has_severity(&self, severity: Severity) -> bool { self.diagnostics.values().any(|errs| errs.iter().any(|e| e.severity == severity)) } pub fn has_errors(&self) -> bool { self.has_severity(Severity::Error) } /// Checks if any error was emitted since the start of the pass, /// Returning all the current information as a `Err(Info)`, replacing `&mut self` with an empty one. /// Otherwise, returns the given arg as an `Ok(T)`. pub fn fatal(&mut self, t: T) -> Result { if !self.has_errors() { Ok(t) } else { Err(std::mem::take(self)) } } /// Returns a Display that prints the diagnostics with one of the given severities. pub fn display_with_severity(&self, severity: Severity) -> impl std::fmt::Display + '_ { DisplayFn(move |f| { // We want to print diagnostics information somewhat like this: // ``` // In file A : // In definition X : // {error} // In definition Y : // {error} // // In file B : // In compiled Inet Z : // {error} // // Other diagnostics: // In {...} // ``` // The problem is, diagnostics data is currently structured as a mapping from something like // DiagnosticOrigin to Vec<(DiagnosticMessage, DiagnosticFile)>, and we would need something // like a mapping from DiagnosticFile to DiagnosticOrigin to Vec in order // to print it cleanly. We might want to change it later to have this structure, // but meanwhile, we do the transformations below to make the goal possible. // Ignore diagnostics without the desired severity. let diagnostics = self .diagnostics .iter() .map(|(origin, diags)| (origin, diags.iter().filter(|diag| diag.severity == severity))); // Produce the structure described above. let groups: BTreeMap<&Option, BTreeMap<&DiagnosticOrigin, Vec<&Diagnostic>>> = diagnostics .fold(BTreeMap::new(), |mut file_tree, (origin, diags)| { for diag in diags { // We need to allow this Clippy warning due to `Name` in `DiagnosticOrigin::Function`. // We know how it works, so it shouldn't be a problem. #[allow(clippy::mutable_key_type)] let file_group_entry = file_tree.entry(&diag.source.file).or_default(); let origin_group_entry = file_group_entry.entry(origin).or_default(); origin_group_entry.push(diag); } file_tree }); // Now, we have a mapping from DiagnosticFile to DiagnosticOrigin to Vec. // If the last file is `None`, it means we only have diagnostics with unknown source file. // In this case, we won't print a special message for them. let only_unknown_file_diagnostics = groups.keys().next_back() == Some(&&None); // Reverse the group iterator so `None` files go last. for (file, origin_to_diagnostics) in groups.iter().rev() { if !only_unknown_file_diagnostics { match &file { Some(name) => writeln!(f, "\x1b[1mIn \x1b[4m{}\x1b[0m\x1b[1m :\x1b[0m", name)?, None => writeln!(f, "\x1b[1mOther diagnostics:\x1b[0m")?, }; } let mut has_msg = false; for (origin, diagnostics) in origin_to_diagnostics { let mut diagnostics = diagnostics.iter().peekable(); if diagnostics.peek().is_some() { match origin { DiagnosticOrigin::Parsing => { for err in diagnostics { writeln!(f, "{err}")?; } } DiagnosticOrigin::Book => { for err in diagnostics { writeln!(f, "{err}")?; } } DiagnosticOrigin::Function(nam) => { writeln!(f, "\x1b[1mIn definition '\x1b[4m{}\x1b[0m\x1b[1m':\x1b[0m", nam)?; for err in diagnostics { writeln!(f, "{:ERR_INDENT_SIZE$}{err}", "")?; } } DiagnosticOrigin::Inet(nam) => { writeln!(f, "\x1b[1mIn compiled inet '\x1b[4m{}\x1b[0m\x1b[1m':\x1b[0m", nam)?; for err in diagnostics { writeln!(f, "{:ERR_INDENT_SIZE$}{err}", "")?; } } DiagnosticOrigin::Readback => { writeln!(f, "\x1b[1mDuring readback:\x1b[0m")?; for err in diagnostics { writeln!(f, "{:ERR_INDENT_SIZE$}{err}", "")?; } } } has_msg = true; } } if has_msg { writeln!(f)?; } } Ok(()) }) } pub fn display_only_messages(&self) -> impl std::fmt::Display + '_ { DisplayFn(move |f| { for err in self.diagnostics.values().flatten() { writeln!(f, "{err}")?; } Ok(()) }) } } impl Display for Diagnostics { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { if self.has_severity(Severity::Warning) { write!(f, "\x1b[4m\x1b[1m\x1b[33mWarnings:\x1b[0m\n{}", self.display_with_severity(Severity::Warning))?; } if self.has_severity(Severity::Error) { write!(f, "\x1b[4m\x1b[1m\x1b[31mErrors:\x1b[0m\n{}", self.display_with_severity(Severity::Error))?; } Ok(()) } } impl From for Diagnostics { fn from(value: String) -> Self { Self { diagnostics: BTreeMap::from_iter([( DiagnosticOrigin::Book, vec![Diagnostic { message: value, severity: Severity::Error, source: Default::default() }], )]), ..Default::default() } } } impl From for Diagnostics { /// Transforms a parse error into `Diagnostics`. /// /// NOTE: Since `ParseError` does not include the source code, we can't get the `TextLocation` of the error, /// so it is not included in the diagnostic. /// range is set as None. fn from(value: ParseError) -> Self { Self { diagnostics: BTreeMap::from_iter([( DiagnosticOrigin::Parsing, vec![Diagnostic { message: value.into(), severity: Severity::Error, source: Default::default() }], )]), ..Default::default() } } } impl DiagnosticsConfig { pub fn new(severity: Severity, verbose: bool) -> Self { Self { irrefutable_match: severity, redundant_match: severity, unreachable_match: severity, unused_definition: severity, repeated_bind: severity, recursion_cycle: severity, import_shadow: severity, // Should only be changed manually, as a missing main is always a error to hvm missing_main: Severity::Error, verbose, } } pub fn warning_severity(&self, warn: WarningType) -> Severity { match warn { WarningType::UnusedDefinition => self.unused_definition, WarningType::RepeatedBind => self.repeated_bind, WarningType::RecursionCycle => self.recursion_cycle, WarningType::IrrefutableMatch => self.irrefutable_match, WarningType::RedundantMatch => self.redundant_match, WarningType::UnreachableMatch => self.unreachable_match, WarningType::MissingMain => self.missing_main, WarningType::ImportShadow => self.import_shadow, } } } impl Default for DiagnosticsConfig { fn default() -> Self { let mut cfg = Self::new(Severity::Warning, false); cfg.recursion_cycle = Severity::Error; cfg } } impl Display for Diagnostic { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { write!(f, "{}", self.message) } } impl Diagnostic { pub fn display_with_origin<'a>(&'a self, origin: &'a DiagnosticOrigin) -> impl std::fmt::Display + 'a { DisplayFn(move |f| { match origin { DiagnosticOrigin::Parsing => writeln!(f, "{self}")?, DiagnosticOrigin::Book => writeln!(f, "{self}")?, DiagnosticOrigin::Function(nam) => { writeln!(f, "\x1b[1mIn definition '\x1b[4m{}\x1b[0m\x1b[1m':\x1b[0m", nam)?; writeln!(f, "{:ERR_INDENT_SIZE$}{self}", "")?; } DiagnosticOrigin::Inet(nam) => { writeln!(f, "\x1b[1mIn compiled inet '\x1b[4m{}\x1b[0m\x1b[1m':\x1b[0m", nam)?; writeln!(f, "{:ERR_INDENT_SIZE$}{self}", "")?; } DiagnosticOrigin::Readback => { writeln!(f, "\x1b[1mDuring readback:\x1b[0m")?; writeln!(f, "{:ERR_INDENT_SIZE$}{self}", "")?; } }; Ok(()) }) } } #[derive(Debug, Copy, Clone, Hash, PartialEq, PartialOrd, Ord, Eq)] pub struct TextLocation { pub line: usize, pub char: usize, } impl TextLocation { pub fn new(line: usize, char: usize) -> Self { TextLocation { line, char } } /// Transforms a `usize` byte index on `code` into a `TextLocation`. pub fn from_byte_loc(code: &str, loc: usize) -> Self { let code = code.as_bytes(); let mut line = 0; let mut char = 0; let mut cur_idx = 0; while cur_idx < loc && cur_idx < code.len() { if code[cur_idx] == b'\n' { line += 1; char = 0; } else { char += 1; } cur_idx += 1; } TextLocation { line, char } } } #[derive(Debug, Copy, Clone, Hash, PartialEq, PartialOrd, Ord, Eq)] pub struct TextSpan { pub start: TextLocation, pub end: TextLocation, } impl TextSpan { pub fn new(start: TextLocation, end: TextLocation) -> Self { TextSpan { start, end } } /// Transforms a `usize` byte range on `code` into a `TextLocation`. pub fn from_byte_span(code: &str, span: Range) -> Self { // Will loop for way too long otherwise assert!(span.start <= span.end); let code = code.as_bytes(); let mut start_line = 0; let mut start_char = 0; let mut end_line; let mut end_char; let mut cur_idx = 0; while cur_idx < span.start && cur_idx < code.len() { if code[cur_idx] == b'\n' { start_line += 1; start_char = 0; } else { start_char += 1; } cur_idx += 1; } end_line = start_line; end_char = start_char; while cur_idx < span.end && cur_idx < code.len() { if code[cur_idx] == b'\n' { end_line += 1; end_char = 0; } else { end_char += 1; } cur_idx += 1; } TextSpan::new(TextLocation::new(start_line, start_char), TextLocation::new(end_line, end_char)) } } ================================================ FILE: src/fun/builtins.bend ================================================ type String: Nil Cons { head: u24, ~tail: String } type List(T): Nil Cons { head: T, ~tail: List(T) } #{ Returns a tuple containing the length and the list itself. #} def List/length(xs: List(T)) -> (u24, List(T)): fold xs with len=0, acc=DiffList/new: case List/Nil: return (len, DiffList/to_list(acc)) case List/Cons: return xs.tail(len + 1, DiffList/append(acc, xs.head)) #{ Reverses the elements of a list. #} def List/reverse(xs: List(T)) -> List(T): fold xs with acc=[]: case List/Nil: return acc case List/Cons: return xs.tail(List/Cons(xs.head, acc)) #{ Returns a flattened list from a list of lists. #} List/flatten (xs: (List (List T))) : (List T) List/flatten (List/Cons x xs) = (List/concat x (List/flatten xs)) List/flatten (List/Nil) = (List/Nil) #{ Appends two lists together. #} List/concat(xs: (List T)) (ys: (List T)) : (List T) List/concat (List/Cons x xs) ys = (List/Cons x (List/concat xs ys)) List/concat (List/Nil) ys = ys #{ Splits a list into two lists at the first occurrence of a value. #} def List/split_once( xs: List(T), cond: T -> u24 ) -> (Result((List(T), List(T)), List(T))): return List/split_once.go(xs, cond, DiffList/new) def List/split_once.go( xs: List(T), cond: T -> u24, acc: List(T) -> List(T) ) -> Result((List(T), List(T)), List(T)): match xs: case List/Nil: return Result/Err(DiffList/to_list(acc)) case List/Cons: if cond(xs.head): return Result/Ok((DiffList/to_list(acc), xs.tail)) else: return List/split_once.go(xs.tail, cond, DiffList/append(acc, xs.head)) #{ Filters a list based on a predicate function. #} List/filter (xs: (List T)) (pred: T -> u24) : (List T) List/filter (List/Nil) _ = List/Nil List/filter (List/Cons x xs) pred = if (pred x) { (List/Cons x (List/filter xs pred)) } else { (List/filter xs pred) } #{ Checks if two strings are equal. #} String/equals (s1: String) (s2: String) : u24 String/equals (String/Nil) (String/Nil) = 1 String/equals (String/Cons x xs) (String/Cons y ys) = if (== x y) { (String/equals xs ys) } else { 0 } String/equals * * = 0 #{ Splits a string into a list of strings based on the given delimiter. #} String/split (s: String) (delimiter: u24) : (List String) String/split s delim = (String/split.go s delim [""]) String/split.go (cs: String) (delim: u24) (acc: (List String)) : (List String) String/split.go (String/Nil) _ acc = (List/reverse acc) String/split.go (String/Cons c cs) delim acc = if (== c delim) { # Start a new split string. (String/split.go cs delim (List/Cons String/Nil acc)) } else { match acc { # Add the current character to the current split string. List/Cons: (String/split.go cs delim (List/Cons (String/Cons c acc.head) acc.tail)) # Should be unreachable. List/Nil: [] } } #{ Create a new difference list #} def DiffList/new() -> (List(T) -> List(T)): return lambda x: x #{ Creates a new difference list with just the given value. #} def DiffList/wrap(head: T) -> (List(T) -> List(T)): return lambda tail: List/Cons(head, tail) #{ Append a value to the end of the difference list #} def DiffList/append(diff: List(T) -> List(T), val: T) -> (List(T) -> List(T)): return lambda x: diff(List/Cons(val, x)) #{ Concatenates two difference lists. #} def DiffList/concat( left: List(T) -> List(T), right: List(T) -> List(T) ) -> (List(T) -> List(T)): return lambda x: left(right(x)) #{ Append a value to the beginning of the difference list #} def DiffList/cons(diff: List(T) -> List(T), val: T) -> (List(T) -> List(T)): return lambda x: List/Cons(val, diff(x)) #{ Converts a difference list to a regular cons list. #} def DiffList/to_list(diff: List(T) -> List(T)) -> (List(T)): return diff(List/Nil) type Nat = (Succ ~(pred: Nat)) | (Zero) type (Result o e) = (Ok (val: o)) | (Err (val: e)) #{ Returns the inner value of `Result/Ok` or `Result/Err`. If the types `A` and `B` are different, should only be used in type unsafe programs or when only one variant is guaranteed to happen. #} def Result/unwrap(res: Result(T, E)) -> Any: match res: case Result/Ok: return res.val case Result/Err: return res.val #{ Returns the second result if the first one is `Ok`. Otherwise, returns the `Err` of the first result. #} def Result/and(fst: Result(A, E), snd: Result(B, E)) -> Result(B, E): match fst: case Result/Ok: return snd case Result/Err: return fst #{ Maps the error value of a result. #} def Result/map_err(res: Result(T, E), f: E -> F) -> Result(T, F): match res: case Result/Ok: return Result/Ok(res.val) case Result/Err: return Result/Err(f(res.val)) type Tree(T): Node { ~left: Tree(T), ~right: Tree(T) } Leaf { value: T } #{ Returns a List converted from a Tree. #} def Tree/to_list(tree: Tree(T)) -> List(T): fold tree: case Tree/Leaf: list = DiffList/wrap(tree.value) case Tree/Node: list = DiffList/concat(tree.left, tree.right) return DiffList/to_list(list) #{ Reverses a tree swapping right and left leaves. #} def Tree/reverse(tree: Tree(T)) -> Tree(T): fold tree: case Tree/Leaf: return !tree.value case Tree/Node: return ![tree.right, tree.left] # MAYBE Impl type Maybe(T): Some { value: T } None #{ Returns the value inside the `Maybe` if it is `Some`, and returns `unreachable()` if it is `None`. #} def Maybe/unwrap(m: Maybe(T)) -> T: match m: case Maybe/Some: return m.value case Maybe/None: return unreachable() # MAP Impl type Map(T): Node { value: Maybe(T), ~left: Map(T), ~right: Map(T) } Leaf #{ Initializes an empty map. #} def Map/empty() -> Map(T): return Map/Leaf #{ Retrieves a `value` from the `map` based on the `key` and returns a tuple with the value and the `map` unchanged. The logic for checking whether a value is or not contained in a `map` is not done in the `get` function, so if we try to get a key that is not in the map, the program will return `unreachable`. #} def Map/get (map: Map(T), key: u24) -> (T, Map(T)): match map: case Map/Leaf: return (unreachable(), map) case Map/Node: if (0 == key): return (Maybe/unwrap(map.value), map) elif (key % 2 == 0): (got, rest) = Map/get(map.left, (key / 2)) return(got, Map/Node(map.value, rest, map.right)) else: (got, rest) = Map/get(map.right, (key / 2)) return(got, Map/Node(map.value, map.left, rest)) #{ Checks if a node has a value on a given key, returning Maybe/Some if it does, Maybe/None otherwise #} def Map/get_check (map: Map(T), key: u24) -> (Maybe(T), Map(T)): match map: case Map/Leaf: return (Maybe/None, map) case Map/Node: if (0 == key): return (map.value, map) elif (key % 2 == 0): (new_value, new_map) = Map/get_check(map.left, (key / 2)) return (new_value, Map/Node(map.value, new_map, map.right)) else: (new_value, new_map) = Map/get_check(map.right, (key / 2)) return (new_value, Map/Node(map.value, map.left, new_map)) #{ Sets a value on a Map, returning the map with the value mapped. #} def Map/set (map: Map(T), key: u24, value: T) -> Map(T): match map: case Map/Node: if (0 == key): return Map/Node(Maybe/Some(value), map.left, map.right) elif ((key % 2) == 0): return Map/Node(map.value, Map/set(map.left, (key / 2), value), map.right) else: return Map/Node(map.value, map.left, Map/set(map.right, (key / 2), value)) case Map/Leaf: if (0 == key): return Map/Node(Maybe/Some(value), Map/Leaf, Map/Leaf) elif ((key % 2) == 0): return Map/Node(Maybe/None, Map/set(Map/Leaf, (key / 2), value), Map/Leaf) else: return Map/Node(Maybe/None, Map/Leaf, Map/set(Map/Leaf, (key / 2),value)) #{ Checks if a `map` contains a given `key` and returns 0 or 1 along with and `map` unchanged. #} def Map/contains (map: Map(T), key: u24) -> (u24, Map(T)): match map: case Map/Leaf: return (0, map) case Map/Node: if (0 == key): match map.value: case Maybe/Some: return (1, map) case Maybe/None: return (0, map) elif ((key % 2) == 0): (new_value, new_map) = Map/contains(map.left, (key / 2)) return (new_value, Map/Node(map.value, new_map, map.right)) else: (new_value, new_map) = Map/contains(map.right, (key / 2)) return (new_value, Map/Node(map.value, map.left, new_map)) #{ Applies a function to a value in the map and returns the map with the value mapped. #} def Map/map (map: Map(T), key: u24, f: T -> T) -> Map(T): match map: case Map/Leaf: return Map/Leaf case Map/Node: if (0 == key): return Map/Node(Maybe/Some(f(Maybe/unwrap(map.value))), map.left, map.right) elif ((key % 2) == 0): return Map/Node(map.value, Map/map(map.left, (key / 2), f), map.right) else: return Map/Node(map.value, map.left, Map/map(map.right, (key / 2), f)) # IO Impl type IO(T): Done { magic: (u24, u24), expr: T } Call { magic: (u24, u24), func: String, argm: Any, cont: Result(Any, IOError(Any)) -> IO(T) } type IOError(T): Type Name Inner { value: T } def IOError/unwrap_inner(err: IOError(T)) -> T: match err: case IOError/Type: return unreachable() case IOError/Name: return unreachable() case IOError/Inner: return err.value def IO/MAGIC() -> (u24, u24): return (0xD0CA11, 0xFF1FF1) def IO/wrap(x: T) -> IO(T): return IO/Done(IO/MAGIC, x) def IO/bind(a: IO(A), b: ((Id -> Id) -> A -> IO(B))) -> IO(B): match a: case IO/Done: return undefer(b, a.expr) case IO/Call: return IO/Call(a.magic, a.func, a.argm, lambda x: IO/bind(a.cont(x), b)) #{ Calls an IO by its name with the given arguments. The arguments are untyped and not checked for type correctness. If type safety is desired, this function should be wrapped with another that checks the types of the arguments and of the return. Always returns a `Result` where the error is an `IOError`, a type that either contains an internal error of the IO function, like an `errno` in the case of FS functions, or a general Bend IO error, like a type error if the arguments are invalid or a name error if the called IO is not found. #} def IO/call(func: String, argm: Any) -> IO(Result(Any, IOError(Any))): return IO/Call(IO/MAGIC, func, argm, lambda x: IO/Done(IO/MAGIC, x)) #{ Maps the result of an IO. #} def IO/map(io: IO(A), f: A -> B) -> IO(B): with IO: a <- io return wrap(f(a)) #{ Unwraps the `IOError` of the result of an IO, returning the `Inner` variant. Should only be called if the other `IOError` variants are unreachable. #} def IO/unwrap_inner(io: IO(Result(A, IOError(B)))) -> IO(Result(A, B)): with IO: res <- io match res: case Result/Ok: return wrap(Result/Ok(res.val)) case Result/Err: return wrap(Result/Err(IOError/unwrap_inner(res.val))) ## Time and sleep #{ Returns a monotonically increasing nanosecond timestamp as an u48 encoded as a pair of u24s. #} def IO/get_time() -> IO((u24, u24)): with IO: res <- IO/call("GET_TIME", *) return wrap(Result/unwrap(res)) #{ Sleeps for the given number of nanoseconds, given by an u48 encoded as a pair of u24s. #} def IO/nanosleep(hi_lo: (u24, u24)) -> IO(None): with IO: res <- IO/call("SLEEP", hi_lo) return wrap(Result/unwrap(res)) #{ Sleeps for a given amount of seconds as a float. #} def IO/sleep(seconds: f24) -> IO(None): nanos = seconds * 1_000_000_000.0 lo = f24/to_u24(nanos % 0x1_000_000.0) hi = f24/to_u24(nanos / 0x1_000_000.0) return IO/nanosleep((hi, lo)) ## File IO ### File IO primitives #{ Opens a file with with `path` being given as a string and `mode` being a string with the mode to open the file in. The mode should be one of the following: "r": Read mode "w": Write mode (write at the beginning of the file, overwriting any existing content) "a": Append mode (write at the end of the file) "r+": Read and write mode "w+": Read and write mode "a+": Read and append mode #} def IO/FS/open(path: String, mode: String) -> IO(Result(u24, u24)): return IO/unwrap_inner(IO/call("OPEN", (path, mode))) #{ Closes the file with the given `file` descriptor. #} def IO/FS/close(file: u24) -> IO(Result(None, u24)): return IO/unwrap_inner(IO/call("CLOSE", file)) #{ Reads `num_bytes` bytes from the file with the given `file` descriptor. Returns a list of U24 with each element representing a byte read from the file. #} def IO/FS/read(file: u24, num_bytes: u24) -> IO(Result(List(u24), u24)): return IO/unwrap_inner(IO/call("READ", (file, num_bytes))) #{ Writes `bytes`, a list of U24 with each element representing a byte, to the file with the given `file` descriptor. Returns nothing (`*`). #} def IO/FS/write(file: u24, bytes: List(u24)) -> IO(Result(None, u24)): return IO/unwrap_inner(IO/call("WRITE", (file, bytes))) #{ Moves the current position of the file with the given `file` descriptor to the given `offset`, an I24 or U24 number, in bytes. #} def IO/FS/seek(file: u24, offset: i24, mode: i24) -> IO(Result(None, u24)): return IO/unwrap_inner(IO/call("SEEK", (file, (offset, mode)))) #{ Flushes the file with the given `file` descriptor. Returns nothing (`*`). #} def IO/FS/flush(file: u24) -> IO(Result(None, u24)): return IO/unwrap_inner(IO/call("FLUSH", file)) ### Always available files IO/FS/STDIN : u24 = 0 IO/FS/STDOUT : u24 = 1 IO/FS/STDERR : u24 = 2 ### Seek modes #{ Seek from start of file. #} IO/FS/SEEK_SET : i24 = +0 #{ Seek from current position. #} IO/FS/SEEK_CUR : i24 = +1 #{ Seek from end of file. #} IO/FS/SEEK_END : i24 = +2 ### File utilities #{ Reads an entire file with the given `path` and returns a list of U24 with each element representing a byte read from the file. #} def IO/FS/read_file(path: String) -> IO(Result(List(u24), u24)): with IO: res_fd <- IO/FS/open(path, "r") match res_fd: case Result/Ok: fd = res_fd.val res1 <- IO/FS/read_to_end(fd) res2 <- IO/FS/close(fd) return wrap(Result/and(res2, res1)) case Result/Err: return wrap(Result/Err(res_fd.val)) #{ Reads until the end of the file with the given `file` descriptor. Returns a list of U24 with each element representing a byte read from the file. #} def IO/FS/read_to_end(fd: u24) -> IO(Result(List(u24), u24)): return IO/FS/read_to_end.read_chunks(fd, []) def IO/FS/read_to_end.read_chunks(fd: u24, chunks: List(List(u24))) -> IO(Result(List(u24), u24)): with IO: # Read file in 1MB chunks res_chunk <- IO/FS/read(fd, 1048576) match res_chunk: case Result/Ok: chunk = res_chunk.val match chunk: case List/Nil: return wrap(Result/Ok(List/flatten(chunks))) case List/Cons: return IO/FS/read_to_end.read_chunks(fd, List/Cons(chunk, chunks)) case Result/Err: return wrap(Result/Err(res_chunk.val)) #{ Reads a line from the file with the given `file` descriptor. Returns a list of U24 with each element representing a byte read from the file. #} def IO/FS/read_line(fd: u24) -> IO(Result(List(u24), u24)): return IO/FS/read_line.read_chunks(fd, []) def IO/FS/read_line.read_chunks(fd: u24, chunks: List(List(u24))) -> IO(Result(List(u24), u24)): with IO: # Read line in 1kB chunks res_chunk <- IO/FS/read(fd, 1024) match res_chunk: case Result/Ok: chunk = res_chunk.val match res = List/split_once(chunk, lambda x: x == '\n'): # Found a newline, backtrack and join chunks case Result/Ok: (line, rest) = res.val (length, *) = List/length(rest) res_seek <- IO/FS/seek(fd, u24/to_i24(length) * -1, IO/FS/SEEK_CUR) match res_seek: case Result/Ok: chunks = List/Cons(line, chunks) bytes = List/flatten(chunks) return wrap(Result/Ok(bytes)) case Result/Err: return wrap(Result/Err(res_seek.val)) # Newline not found case Result/Err: line = res.val (length, line) = List/length(line) # If length is 0, the end of the file was reached, return as if it was a newline if length == 0: bytes = List/flatten(chunks) return wrap(Result/Ok(bytes)) # Otherwise, the line is still ongoing, read more chunks else: chunks = List/Cons(line, chunks) return IO/FS/read_line.read_chunks(fd, chunks) case Result/Err: return wrap(Result/Err(res_chunk.val)) #{ Writes `bytes`, a list of U24 with each element representing a byte, as the entire content of the file with the given `path`. #} def IO/FS/write_file(path: String, bytes: List(u24)) -> IO(Result(None, u24)): with IO: res_f <- IO/FS/open(path, "w") match res_f: case Result/Ok: f = res_f.val res1 <- IO/FS/write(f, bytes) res2 <- IO/FS/close(f) return wrap(Result/and(res2, res1)) case Result/Err: return wrap(Result/Err(res_f.val)) ### Standard input and output utilities #{ Prints the string `text` to the standard output, encoded with utf-8. #} def IO/print(text: String) -> IO(None): with IO: res <- IO/FS/write(IO/FS/STDOUT, String/encode_utf8(text)) return wrap(Result/unwrap(res)) #{ IO/input() -> IO String Reads characters from the standard input until a newline is found. Returns the read input as a String decoded with utf-8. #} def IO/input() -> IO(Result(String, u24)): return IO/input.go(DiffList/new) def IO/input.go(acc: List(u24) -> List(u24)) -> IO(Result(String, u24)): # TODO: This is slow and inefficient, should be done in hvm using fgets. with IO: res_byte <- IO/FS/read(IO/FS/STDIN, 1) match res_byte: case Result/Ok: byte = res_byte.val match byte: case List/Nil: # Nothing read, try again (to simulate blocking a read) return IO/input.go(acc) case List/Cons: if byte.head == '\n': bytes = DiffList/to_list(acc) text = String/decode_utf8(bytes) return wrap(Result/Ok(text)) else: acc = DiffList/append(acc, byte.head) return IO/input.go(acc) case Result/Err: return wrap(Result/Err(res_byte.val)) ### Dynamically linked libraries #{ Loads a dynamic library file. #} def IO/DyLib/open(path: String, lazy: u24) -> IO(Result(u24, String)): return IO/unwrap_inner(IO/call("DL_OPEN", (path, lazy))) #{ - `path` is the path to the library file. - `lazy` is a boolean encoded as a `u24` that determines if all functions are loaded lazily (`1`) or upfront (`0`). - Returns an unique id to the library object encoded as a `u24`. #} #{ Calls a function of a previously opened library. - `dl` is the id of the library object. - `fn` is the name of the function in the library. - `args` are the arguments to the function. The expected values depend on the called function. - The returned value is determined by the called function. #} def IO/DyLib/call(dl: u24, fn: String, args: Any) -> IO(Result(Any, String)): return IO/unwrap_inner(IO/call("DL_CALL", (dl, (fn, args)))) #{ Closes a previously open library. - `dl` is the id of the library object. - Returns nothing (`*`). #} def IO/DyLib/close(dl: u24) -> IO(Result(None, String)): return IO/unwrap_inner(IO/call("DL_CLOSE", dl)) # Lazy thunks #{ We can defer the evaluation of a function by wrapping it in a thunk. Ex: @x (x @arg1 @arg2 @arg3 (f arg1 arg2 arg3) arg1 arg2 arg3) This is only evaluated when we call it with `(undefer my_thunk)`. We can build a defered call directly or by by using `defer` and `defer_arg`. The example above can be written as: (defer_arg (defer_arg (defer_arg (defer @arg1 @arg2 @arg3 (f arg1 arg2 arg3)) arg1) arg2) arg3) #} def defer(val: T) -> (T -> T) -> T: return lambda x: x(val) def defer_arg(defered: (Id -> Id) -> A -> B, arg: A) -> ((Id -> Id) -> B): return lambda x: defered(x, arg) def undefer(defered: (Id -> Id) -> T) -> T: return defered(lambda x: x) #{ A function that can be used in unreachable code. Is not type safe and if used in code that is actually reachable, will corrupt the program. #} def unreachable() -> Any: return * # Native number casts #{ Casts a f24 number to a u24. #} hvm f24/to_u24 -> (f24 -> u24): ($([u24] ret) ret) #{ Casts an i24 number to a u24. #} hvm i24/to_u24 -> (i24 -> u24): ($([u24] ret) ret) #{ Casts a u24 number to an i24. #} hvm u24/to_i24 -> (u24 -> i24): ($([i24] ret) ret) #{ Casts a f24 number to an i24. #} hvm f24/to_i24 -> (f24 -> i24): ($([i24] ret) ret) #{ Casts a u24 number to a f24. #} hvm u24/to_f24 -> (u24 -> f24): ($([f24] ret) ret) #{ Casts an i24 number to a f24. #} hvm i24/to_f24 -> (i24 -> f24): ($([f24] ret) ret) #{ Casts an u24 native number to a string. #} def u24/to_string(n: u24) -> String: def go(n: u24) -> String -> String: r = n % 10 d = n / 10 c = '0' + r if d == 0: return lambda t: String/Cons(c, t) else: return lambda t: go(d, String/Cons(c, t)) return go(n, String/Nil) #{ String Encoding and Decoding #} Utf8/REPLACEMENT_CHARACTER : u24 = '\u{FFFD}' #{ Decodes a sequence of bytes to a String using utf-8 encoding. #} String/decode_utf8 (bytes: (List u24)) : String String/decode_utf8 [] = String/Nil String/decode_utf8 bytes = let (got, rest) = (Utf8/decode_character bytes) match rest { List/Nil: (String/Cons got String/Nil) List/Cons: (String/Cons got (String/decode_utf8 rest)) } #{ Decodes a utf-8 character, returns a tuple containing the rune and the rest of the byte sequence. #} Utf8/decode_character (bytes: (List u24)) : (u24, (List u24)) Utf8/decode_character [] = (0, []) Utf8/decode_character [a] = if (<= a 0x7F) { (a, []) } else { (Utf8/REPLACEMENT_CHARACTER, []) } Utf8/decode_character [a, b] = use Utf8/maskx = 0b00111111 use Utf8/mask2 = 0b00011111 if (<= a 0x7F) { (a, [b]) } else { if (== (& a 0xE0) 0xC0) { let r = (| (<< (& a Utf8/mask2) 6) (& b Utf8/maskx)) (r, []) } else { (Utf8/REPLACEMENT_CHARACTER, []) } } Utf8/decode_character [a, b, c] = use Utf8/maskx = 0b00111111 use Utf8/mask2 = 0b00011111 use Utf8/mask3 = 0b00001111 if (<= a 0x7F) { (a, [b, c]) } else { if (== (& a 0xE0) 0xC0) { let r = (| (<< (& a Utf8/mask2) 6) (& b Utf8/maskx)) (r, [c]) } else { if (== (& a 0xF0) 0xE0) { let r = (| (<< (& a Utf8/mask3) 12) (| (<< (& b Utf8/maskx) 6) (& c Utf8/maskx))) (r, []) } else { (Utf8/REPLACEMENT_CHARACTER, []) } } } Utf8/decode_character (List/Cons a (List/Cons b (List/Cons c (List/Cons d rest)))) = use Utf8/maskx = 0b00111111 use Utf8/mask2 = 0b00011111 use Utf8/mask3 = 0b00001111 use Utf8/mask4 = 0b00000111 if (<= a 0x7F) { (a, (List/Cons b (List/Cons c (List/Cons d rest)))) } else { if (== (& a 0xE0) 0xC0) { let r = (| (<< (& a Utf8/mask2) 6) (& b Utf8/maskx)) (r, (List/Cons c (List/Cons d rest))) } else { if (== (& a 0xF0) 0xE0) { let r = (| (<< (& a Utf8/mask3) 12) (| (<< (& b Utf8/maskx) 6) (& c Utf8/maskx))) (r, (List/Cons d rest)) } else { if (== (& a 0xF8) 0xF0) { let r = (| (<< (& a Utf8/mask4) 18) (| (<< (& b Utf8/maskx) 12) (| (<< (& c Utf8/maskx) 6) (& d Utf8/maskx)))) (r, rest) } else { (Utf8/REPLACEMENT_CHARACTER, rest) } } } } #{ Encodes a string to a sequence of bytes using utf-8 encoding. #} String/encode_utf8 (str: String) : (List u24) String/encode_utf8 (String/Nil) = (List/Nil) String/encode_utf8 (String/Cons x xs) = use Utf8/rune1max = 0b01111111 use Utf8/rune2max = 0b00000111_11111111 use Utf8/rune3max = 0b11111111_11111111 use Utf8/tx = 0b10000000 use Utf8/t2 = 0b11000000 use Utf8/t3 = 0b11100000 use Utf8/t4 = 0b11110000 use Utf8/maskx = 0b00111111 if (<= x Utf8/rune1max) { (List/Cons x (String/encode_utf8 xs)) } else { if (<= x Utf8/rune2max) { let b1 = (| Utf8/t2 (>> x 6)) let b2 = (| Utf8/tx (& x Utf8/maskx)) (List/Cons b1 (List/Cons b2 (String/encode_utf8 xs))) } else { if (<= x Utf8/rune3max) { let b1 = (| Utf8/t3 (>> x 12)) let b2 = (| Utf8/tx (& (>> x 6) Utf8/maskx)) let b3 = (| Utf8/tx (& x Utf8/maskx)) (List/Cons b1 (List/Cons b2 (List/Cons b3 (String/encode_utf8 xs)))) } else { let b1 = (| Utf8/t4 (>> x 18)) let b2 = (| Utf8/tx (& (>> x 12) Utf8/maskx)) let b3 = (| Utf8/tx (& (>> x 6) Utf8/maskx)) let b4 = (| Utf8/tx (& x Utf8/maskx)) (List/Cons b1 (List/Cons b2 (List/Cons b3 (List/Cons b4 (String/encode_utf8 xs))))) } } } #{ Decodes a sequence of bytes to a String using ascii encoding. #} String/decode_ascii (bytes: (List u24)) : String String/decode_ascii (List/Cons x xs) = (String/Cons x (String/decode_ascii xs)) String/decode_ascii (List/Nil) = (String/Nil) #{ Encodes a string to a sequence of bytes using ascii encoding. #} String/encode_ascii (str: String) : (List u24) String/encode_ascii (String/Cons x xs) = (List/Cons x (String/encode_ascii xs)) String/encode_ascii (String/Nil) = (List/Nil) # Math #{ The Pi (π) constant.#} def Math/PI() -> f24: return 3.1415926535 #{ Euler's number #} def Math/E() -> f24: return 2.718281828 #{ Math/log(x: f24, base: f24) -> f24 Computes the logarithm of `x` with the specified `base`. #} hvm Math/log -> (f24 -> f24 -> f24): (x ($([|] $(x ret)) ret)) #{ Math/atan2(x: f24, y: f24) -> f24 Computes the arctangent of `y / x`. Has the same behaviour as `atan2f` in the C math lib. #} hvm Math/atan2 -> (f24 -> f24 -> f24): ($([&] $(y ret)) (y ret)) #{ Math/sin(a: f24) -> f24 Computes the sine of the given angle in radians. #} hvm Math/sin -> (f24 -> f24): ($([<<0x0] a) a) #{ Math/cos(a: f24) -> f24 Computes the cosine of the given angle in radians. #} hvm Math/cos -> (f24 -> f24): (a b) & @Math/PI ~ $([:/2.0] $([-] $(a $([<<0x0] b)))) #{ Math/tan(a: f24) -> f24 Computes the tangent of the given angle in radians. #} hvm Math/tan -> (f24 -> f24): ($([>>0x0] a) a) #{ Computes the cotangent of the given angle in radians. #} Math/cot (a: f24) : f24 = (/ 1.0 (Math/tan a)) #{ Computes the secant of the given angle in radians. #} Math/sec (a: f24) : f24 = (/ 1.0 (Math/cos a)) #{ Computes the cosecant of the given angle in radians. #} Math/csc (a: f24) : f24 = (/ 1.0 (Math/sin a)) #{ Computes the arctangent of the given angle. #} Math/atan (a: f24) : f24 = (Math/atan2 a 1.0) #{ Computes the arcsine of the given angle. #} Math/asin (a: f24) : f24 = (Math/atan2 a (Math/sqrt (- 1.0 (* a a)))) #{ Computes the arccosine of the given angle. #} Math/acos (a: f24) : f24 = (Math/atan2 (Math/sqrt (- 1.0 (* a a))) a) #{ Converts degrees to radians. #} Math/radians (a: f24) : f24 = (* a (/ Math/PI 180.0)) #{ Computes the square root of the given number. #} Math/sqrt (n: f24) : f24 = (** n 0.5) #{ Round float up to the nearest integer. #} def Math/ceil(n: f24) -> f24: i_n = i24/to_f24(f24/to_i24(n)) if n <= i_n: return i_n else: return i_n + 1.0 #{ Round float down to the nearest integer. #} def Math/floor(n: f24) -> f24: i_n = i24/to_f24(f24/to_i24(n)) if n < i_n: return i_n - 1.0 else: return i_n #{ Round float to the nearest integer. #} def Math/round(n: f24) -> f24: i_n = i24/to_f24(f24/to_i24(n)) if (n - i_n) < 0.5: return Math/floor(n) else: return Math/ceil(n) ================================================ FILE: src/fun/builtins.rs ================================================ use super::{ parser::{FunParser, ParseBook}, Book, Name, Num, Pattern, Term, }; use crate::maybe_grow; const BUILTINS: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/fun/builtins.bend")); pub const LIST: &str = "List"; pub const LCONS: &str = "List/Cons"; pub const LNIL: &str = "List/Nil"; pub const LCONS_TAG: u32 = 1; pub const LNIL_TAG_REF: &str = "List/Nil/tag"; pub const LCONS_TAG_REF: &str = "List/Cons/tag"; pub const HEAD: &str = "head"; pub const TAIL: &str = "tail"; pub const STRING: &str = "String"; pub const SCONS: &str = "String/Cons"; pub const SNIL: &str = "String/Nil"; pub const SCONS_TAG: u32 = 1; pub const SNIL_TAG_REF: &str = "String/Nil/tag"; pub const SCONS_TAG_REF: &str = "String/Cons/tag"; pub const NAT: &str = "Nat"; pub const NAT_SUCC: &str = "Nat/Succ"; pub const NAT_ZERO: &str = "Nat/Zero"; pub const NAT_SUCC_TAG: u32 = 0; pub const TREE: &str = "Tree"; pub const TREE_NODE: &str = "Tree/Node"; pub const TREE_LEAF: &str = "Tree/Leaf"; pub const MAP: &str = "Map"; pub const MAP_NODE: &str = "Map/Node"; pub const MAP_LEAF: &str = "Map/Leaf"; pub const IO: &str = "IO"; pub const IO_DONE: &str = "IO/Done"; pub const IO_CALL: &str = "IO/Call"; pub const BUILTIN_CTRS: &[&str] = &[LCONS, LNIL, SCONS, SNIL, NAT_SUCC, NAT_ZERO, TREE_NODE, TREE_LEAF, MAP_NODE, MAP_LEAF, IO_DONE, IO_CALL]; pub const BUILTIN_TYPES: &[&str] = &[LIST, STRING, NAT, TREE, MAP, IO]; impl ParseBook { pub fn builtins() -> Self { let book = FunParser::new(Name::new("/src/fun/builtins.bend"), BUILTINS, true).parse_book(Self::default()); book.unwrap_or_else(|e| panic!("Error parsing builtin file, this should not happen:\n{e}")) } } impl Book { pub fn encode_builtins(&mut self) { for def in self.defs.values_mut() { for rule in def.rules.iter_mut() { rule.pats.iter_mut().for_each(Pattern::encode_builtins); rule.body.encode_builtins(); } } } } impl Term { fn encode_builtins(&mut self) { maybe_grow(|| match self { Term::List { els } => *self = Term::encode_list(std::mem::take(els)), Term::Str { val } => *self = Term::encode_str(val), Term::Nat { val } => *self = Term::encode_nat(*val), Term::Def { def, nxt } => { for rule in def.rules.iter_mut() { rule.pats.iter_mut().for_each(Pattern::encode_builtins); rule.body.encode_builtins(); } nxt.encode_builtins(); } _ => { for child in self.children_mut() { child.encode_builtins(); } } }) } fn encode_list(elements: Vec) -> Term { elements.into_iter().rfold(Term::r#ref(LNIL), |acc, mut nxt| { nxt.encode_builtins(); Term::call(Term::r#ref(LCONS), [nxt, acc]) }) } pub fn encode_str(val: &str) -> Term { val.chars().rfold(Term::r#ref(SNIL), |acc, char| { Term::call(Term::r#ref(SCONS), [Term::Num { val: Num::U24(char as u32 & 0x00ff_ffff) }, acc]) }) } pub fn encode_nat(val: u32) -> Term { (0..val).fold(Term::r#ref(NAT_ZERO), |acc, _| Term::app(Term::r#ref(NAT_SUCC), acc)) } } impl Pattern { pub fn encode_builtins(&mut self) { match self { Pattern::Lst(pats) => *self = Self::encode_list(std::mem::take(pats)), Pattern::Str(str) => *self = Self::encode_str(str), _ => { for pat in self.children_mut() { pat.encode_builtins(); } } } } fn encode_list(elements: Vec) -> Pattern { let lnil = Pattern::Ctr(Name::new(LNIL), vec![]); elements.into_iter().rfold(lnil, |acc, mut nxt| { nxt.encode_builtins(); Pattern::Ctr(Name::new(LCONS), vec![nxt, acc]) }) } fn encode_str(str: &str) -> Pattern { let lnil = Pattern::Ctr(Name::new(SNIL), vec![]); str.chars().rfold(lnil, |tail, head| { let head = Pattern::Num(head as u32); Pattern::Ctr(Name::new(SCONS), vec![head, tail]) }) } } ================================================ FILE: src/fun/check/check_untyped.rs ================================================ use crate::{ diagnostics::Diagnostics, fun::{Ctx, FanKind, Pattern, Tag, Term}, maybe_grow, }; impl Ctx<'_> { /// Checks that terms that cannot be typed are only used inside untyped functions. pub fn check_untyped_terms(&mut self) -> Result<(), Diagnostics> { for def in self.book.defs.values() { if def.check { for rule in def.rules.iter() { if let Err(e) = rule.body.check_untyped_terms() { self.info.add_function_error(e, def.name.clone(), def.source.clone()); } } } } self.info.fatal(()) } } impl Term { fn check_untyped_terms(&self) -> Result<(), String> { maybe_grow(|| { match self { Term::Lam { tag: Tag::Static, pat, .. } => pat.check_untyped_patterns()?, Term::Lam { tag: _, .. } => { return Err("Tagged lambda in type-checked function".to_string()); } Term::Link { nam } => { return Err(format!("Unscoped variable '${nam}' in type-checked function")); } Term::App { tag: Tag::Static, .. } => {} Term::App { tag: _, .. } => { return Err("Tagged application in type-checked function".to_string()); } Term::Fan { fan: FanKind::Dup, .. } => { return Err("Superposition term in type-checked function".to_string()); } Term::Fan { fan: FanKind::Tup, tag: Tag::Static, .. } => {} Term::Fan { fan: FanKind::Tup, tag: _, .. } => { return Err("Tagged tuple in type-checked function".to_string()); } Term::Let { pat, .. } => { pat.check_untyped_patterns()?; } _ => {} } for child in self.children() { child.check_untyped_terms()?; } Ok(()) }) } } impl Pattern { fn check_untyped_patterns(&self) -> Result<(), String> { maybe_grow(|| { match self { Pattern::Chn(x) => { return Err(format!("Unscoped variable bind '${x}' in type-checked function")); } Pattern::Fan(FanKind::Dup, Tag::Auto, _) => {} Pattern::Fan(FanKind::Dup, _, _) => { return Err("Tagged duplication in type-checked function".to_string()); } Pattern::Fan(FanKind::Tup, Tag::Static, _) => {} Pattern::Fan(FanKind::Tup, _, _) => { return Err("Tagged tuple elimination in type-checked function".to_string()); } _ => {} } for pat in self.children() { pat.check_untyped_patterns()?; } Ok(()) }) } } ================================================ FILE: src/fun/check/mod.rs ================================================ pub mod check_untyped; pub mod set_entrypoint; pub mod shared_names; pub mod type_check; pub mod unbound_refs; pub mod unbound_vars; ================================================ FILE: src/fun/check/set_entrypoint.rs ================================================ use crate::{ diagnostics::WarningType, fun::{Book, Ctx, Definition, Name}, ENTRY_POINT, HVM1_ENTRY_POINT, }; #[derive(Debug, Clone)] pub enum EntryErr { NotFound(Name), Multiple(Vec), MultipleRules, } impl Ctx<'_> { pub fn set_entrypoint(&mut self) { let mut entrypoint = None; let (custom, main, hvm1_main) = self.book.get_possible_entry_points(); match (custom, main, hvm1_main) { (Some(entry), None, None) | (None, Some(entry), None) | (None, None, Some(entry)) => { match validate_entry_point(entry) { Ok(name) => entrypoint = Some(name), Err(err) => self.info.add_book_error(err), } } (Some(a), Some(b), None) | (None, Some(a), Some(b)) | (Some(a), None, Some(b)) => { self.info.add_book_error(EntryErr::Multiple(vec![a.name.clone(), b.name.clone()])); match validate_entry_point(a) { Ok(name) => entrypoint = Some(name), Err(err) => self.info.add_book_error(err), } } (Some(a), Some(b), Some(c)) => { self.info.add_book_error(EntryErr::Multiple(vec![a.name.clone(), b.name.clone(), c.name.clone()])); match validate_entry_point(a) { Ok(name) => entrypoint = Some(name), Err(err) => self.info.add_book_error(err), } } (None, None, None) => { let entrypoint = self.book.entrypoint.clone().unwrap_or(Name::new(ENTRY_POINT)); self.info.add_book_warning(EntryErr::NotFound(entrypoint), WarningType::MissingMain) } } self.book.entrypoint = entrypoint; } } fn validate_entry_point(entry: &Definition) -> Result { if entry.rules.len() > 1 { Err(EntryErr::MultipleRules) } else { Ok(entry.name.clone()) } } impl Book { fn get_possible_entry_points(&self) -> (Option<&Definition>, Option<&Definition>, Option<&Definition>) { let custom = self.entrypoint.as_ref().and_then(|e| self.defs.get(e)); let main = self.defs.get(&Name::new(ENTRY_POINT)); let hvm1_main = self.defs.get(&Name::new(HVM1_ENTRY_POINT)); (custom, main, hvm1_main) } } impl std::fmt::Display for EntryErr { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { EntryErr::NotFound(name) => write!(f, "File has no '{name}' definition."), EntryErr::Multiple(fnd) if fnd.len() == 2 => { write!(f, "File has both '{}' and '{}' definitions.", fnd[0], fnd[1]) } EntryErr::Multiple(fnd) => { write!(f, "File has '{}', '{}' and '{}' definitions.", fnd[0], fnd[1], fnd[2]) } EntryErr::MultipleRules => write!(f, "Main definition can't have more than one rule."), } } } ================================================ FILE: src/fun/check/shared_names.rs ================================================ use crate::fun::{Ctx, Name}; use indexmap::IndexMap; use std::fmt::Display; #[derive(Debug, Clone)] pub struct RepeatedTopLevelNameErr { kind_fst: NameKind, kind_snd: NameKind, name: Name, } impl Ctx<'_> { /// Checks if there are any repeated top level names. Constructors /// and functions can't share names and adts can't share names. pub fn check_shared_names(&mut self) { let mut names = NameInfo::default(); for adt_name in self.book.adts.keys() { names.add_name(adt_name, NameKind::Adt); } for ctr_name in self.book.ctrs.keys() { names.add_name(ctr_name, NameKind::Ctr); } for def_name in self.book.defs.keys() { names.add_name(def_name, NameKind::Def); } for err in names.into_errs() { self.info.add_book_error(err); } } } #[derive(Debug, Clone, Copy)] enum NameKind { Adt, Def, Ctr, } #[derive(Debug, Default)] struct NameInfo<'a>(IndexMap<&'a Name, Vec>); impl<'a> NameInfo<'a> { fn add_name(&mut self, name: &'a Name, kind: NameKind) { self.0.entry(name).or_default().push(kind); } fn into_errs(self) -> Vec { let mut errs = vec![]; for (name, kinds) in self.0 { let mut num_adts = 0; let mut fst_ctr_def = None; for kind in kinds { if let NameKind::Adt = kind { num_adts += 1; if num_adts >= 2 { errs.push(RepeatedTopLevelNameErr { kind_fst: NameKind::Adt, kind_snd: NameKind::Adt, name: name.clone(), }); } } else if let Some(fst) = fst_ctr_def { errs.push(RepeatedTopLevelNameErr { kind_fst: fst, kind_snd: kind, name: name.clone() }); } else { fst_ctr_def = Some(kind); } } } errs } } impl Display for NameKind { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { NameKind::Adt => write!(f, "data type"), NameKind::Def => write!(f, "function"), NameKind::Ctr => write!(f, "constructor"), } } } impl std::fmt::Display for RepeatedTopLevelNameErr { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let mut snd = self.kind_snd.to_string(); snd[0..1].make_ascii_uppercase(); write!(f, "{} '{}' has the same name as a previously defined {}", snd, self.name, self.kind_fst) } } ================================================ FILE: src/fun/check/type_check.rs ================================================ //! Optional Hindley-Milner-like type system. //! //! Based on https://github.com/developedby/algorithm-w-rs //! and https://github.com/mgrabmueller/AlgorithmW. use crate::{ diagnostics::Diagnostics, fun::{num_to_name, Adt, Book, Ctx, FanKind, MatchRule, Name, Num, Op, Pattern, Tag, Term, Type}, maybe_grow, }; use std::collections::{BTreeMap, BTreeSet, HashMap}; impl Ctx<'_> { pub fn type_check(&mut self) -> Result<(), Diagnostics> { let types = infer_book(self.book, &mut self.info)?; for def in self.book.defs.values_mut() { def.typ = types[&def.name].instantiate(&mut VarGen::default()); } Ok(()) } } type ProgramTypes = HashMap; /// A type scheme, aka a polymorphic type. #[derive(Clone, Debug)] struct Scheme(Vec, Type); /// A finite mapping from type variables to types. #[derive(Clone, Default, Debug)] struct Subst(BTreeMap); /// A mapping from term variables to type schemes. #[derive(Clone, Default, Debug)] struct TypeEnv(BTreeMap); /// Variable generator for type variables. #[derive(Default)] struct VarGen(usize); /// Topologically ordered set of mutually recursive groups of functions. struct RecGroups(Vec>); /* Implementations */ impl Type { fn free_type_vars(&self) -> BTreeSet { maybe_grow(|| match self { Type::Var(x) => BTreeSet::from([x.clone()]), Type::Ctr(_, ts) | Type::Tup(ts) => ts.iter().flat_map(|t| t.free_type_vars()).collect(), Type::Arr(t1, t2) => t1.free_type_vars().union(&t2.free_type_vars()).cloned().collect(), Type::Number(t) | Type::Integer(t) => t.free_type_vars(), Type::U24 | Type::F24 | Type::I24 | Type::None | Type::Any | Type::Hole => BTreeSet::new(), }) } fn subst(&self, subst: &Subst) -> Type { maybe_grow(|| match self { Type::Var(nam) => match subst.0.get(nam) { Some(new) => new.clone(), None => self.clone(), }, Type::Ctr(name, ts) => Type::Ctr(name.clone(), ts.iter().map(|t| t.subst(subst)).collect()), Type::Arr(t1, t2) => Type::Arr(Box::new(t1.subst(subst)), Box::new(t2.subst(subst))), Type::Tup(els) => Type::Tup(els.iter().map(|t| t.subst(subst)).collect()), Type::Number(t) => Type::Number(Box::new(t.subst(subst))), Type::Integer(t) => Type::Integer(Box::new(t.subst(subst))), t @ (Type::U24 | Type::F24 | Type::I24 | Type::None | Type::Any | Type::Hole) => t.clone(), }) } /// Converts a monomorphic type into a type scheme by abstracting /// over the type variables free in `t`, but not free in the type /// environment. fn generalize(&self, env: &TypeEnv) -> Scheme { let vars_env = env.free_type_vars(); let vars_t = self.free_type_vars(); let vars = vars_t.difference(&vars_env).cloned().collect(); Scheme(vars, self.clone()) } } impl Scheme { fn free_type_vars(&self) -> BTreeSet { let vars = self.1.free_type_vars(); let bound_vars = self.0.iter().cloned().collect(); vars.difference(&bound_vars).cloned().collect() } fn subst(&self, subst: &Subst) -> Scheme { let mut subst = subst.clone(); for x in self.0.iter() { subst.0.remove(x); } let t = self.1.subst(&subst); Scheme(self.0.clone(), t) } /// Converts a type scheme into a monomorphic type by assigning /// fresh type variables to each variable bound by the scheme. fn instantiate(&self, var_gen: &mut VarGen) -> Type { let new_vars = self.0.iter().map(|_| var_gen.fresh()); let subst = Subst(self.0.iter().cloned().zip(new_vars).collect()); self.1.subst(&subst) } } impl Subst { /// Compose two substitutions. /// /// Applies the first substitution to the second, and then inserts the result into the first. fn compose(mut self, other: Subst) -> Subst { let other = other.0.into_iter().map(|(x, t)| (x, t.subst(&self))).collect::>(); self.0.extend(other); self } } impl TypeEnv { fn free_type_vars(&self) -> BTreeSet { let mut vars = BTreeSet::new(); for scheme in self.0.values() { let scheme_vars = scheme.free_type_vars(); vars = vars.union(&scheme_vars).cloned().collect(); } vars } fn subst(&self, subst: &Subst) -> TypeEnv { let env = self.0.iter().map(|(x, scheme)| (x.clone(), scheme.subst(subst))).collect(); TypeEnv(env) } fn insert(&mut self, name: Name, scheme: Scheme) { self.0.insert(name, scheme); } fn add_binds<'a>( &mut self, bnd: impl IntoIterator, Scheme)>, ) -> Vec<(Name, Option)> { let mut old_bnd = vec![]; for (name, scheme) in bnd { if let Some(name) = name { let old = self.0.insert(name.clone(), scheme); old_bnd.push((name.clone(), old)); } } old_bnd } fn pop_binds(&mut self, old_bnd: Vec<(Name, Option)>) { for (name, scheme) in old_bnd { if let Some(scheme) = scheme { self.0.insert(name, scheme); } } } } impl VarGen { fn fresh(&mut self) -> Type { let x = self.fresh_name(); Type::Var(x) } fn fresh_name(&mut self) -> Name { let x = num_to_name(self.0 as u64); self.0 += 1; Name::new(x) } } impl RecGroups { fn from_book(book: &Book) -> RecGroups { type DependencyGraph<'a> = BTreeMap<&'a Name, BTreeSet<&'a Name>>; fn collect_dependencies<'a>( term: &'a Term, book: &'a Book, scope: &mut Vec, deps: &mut BTreeSet<&'a Name>, ) { if let Term::Ref { nam } = term { if book.ctrs.contains_key(nam) || book.hvm_defs.contains_key(nam) || !book.defs[nam].check { // Don't infer types for constructors or unchecked functions } else { deps.insert(nam); } } for (child, binds) in term.children_with_binds() { scope.extend(binds.clone().flatten().cloned()); collect_dependencies(child, book, scope, deps); scope.truncate(scope.len() - binds.flatten().count()); } } /// Tarjan's algorithm for finding strongly connected components. fn strong_connect<'a>( v: &'a Name, deps: &DependencyGraph<'a>, index: &mut usize, index_map: &mut BTreeMap<&'a Name, usize>, low_link: &mut BTreeMap<&'a Name, usize>, stack: &mut Vec<&'a Name>, components: &mut Vec>, ) { maybe_grow(|| { index_map.insert(v, *index); low_link.insert(v, *index); *index += 1; stack.push(v); if let Some(neighbors) = deps.get(v) { for w in neighbors { if !index_map.contains_key(w) { // Successor w has not yet been visited, recurse on it. strong_connect(w, deps, index, index_map, low_link, stack, components); low_link.insert(v, low_link[v].min(low_link[w])); } else if stack.contains(w) { // Successor w is in stack S and hence in the current SCC. low_link.insert(v, low_link[v].min(index_map[w])); } else { // If w is not on stack, then (v, w) is an edge pointing // to an SCC already found and must be ignored. } } } // If v is a root node, pop the stack and generate an SCC. if low_link[v] == index_map[v] { let mut component = BTreeSet::new(); while let Some(w) = stack.pop() { component.insert(w.clone()); if w == v { break; } } components.push(component); } }) } // Build the dependency graph let mut deps = DependencyGraph::default(); for (name, def) in &book.defs { if book.ctrs.contains_key(name) || !def.check { // Don't infer types for constructors or unchecked functions continue; } let mut fn_deps = Default::default(); collect_dependencies(&def.rule().body, book, &mut vec![], &mut fn_deps); deps.insert(name, fn_deps); } let mut index = 0; let mut stack = Vec::new(); let mut index_map = BTreeMap::new(); let mut low_link = BTreeMap::new(); let mut components = Vec::new(); for name in deps.keys() { if !index_map.contains_key(name) { strong_connect(name, &deps, &mut index, &mut index_map, &mut low_link, &mut stack, &mut components); } } let components = components.into_iter().map(|x| x.into_iter().collect()).collect(); RecGroups(components) } } /* Inference, unification and type checking */ fn infer_book(book: &Book, diags: &mut Diagnostics) -> Result { let groups = RecGroups::from_book(book); let mut env = TypeEnv::default(); // Note: We store the inferred and generalized types in a separate // environment, to avoid unnecessary cloning (since no immutable data). let mut types = ProgramTypes::default(); // Add the constructors to the environment. for adt in book.adts.values() { for ctr in adt.ctrs.values() { types.insert(ctr.name.clone(), ctr.typ.generalize(&TypeEnv::default())); } } // Add the types of unchecked functions to the environment. for def in book.defs.values() { if !def.check { types.insert(def.name.clone(), def.typ.generalize(&TypeEnv::default())); } } // Add the types of hvm functions to the environment. for def in book.hvm_defs.values() { types.insert(def.name.clone(), def.typ.generalize(&TypeEnv::default())); } // Infer the types of regular functions. for group in &groups.0 { infer_group(&mut env, book, group, &mut types, diags)?; } Ok(types) } fn infer_group( env: &mut TypeEnv, book: &Book, group: &[Name], types: &mut ProgramTypes, diags: &mut Diagnostics, ) -> Result<(), Diagnostics> { let var_gen = &mut VarGen::default(); // Generate fresh type variables for each function in the group. let tvs = group.iter().map(|_| var_gen.fresh()).collect::>(); for (name, tv) in group.iter().zip(tvs.iter()) { env.insert(name.clone(), Scheme(vec![], tv.clone())); } // Infer the types of the functions in the group. let mut ss = vec![]; let mut inf_ts = vec![]; let mut exp_ts = vec![]; for name in group { let def = &book.defs[name]; let (s, t) = infer(env, book, types, &def.rule().body, var_gen).map_err(|e| { diags.add_function_error(e, name.clone(), def.source.clone()); std::mem::take(diags) })?; let t = t.subst(&s); ss.push(s); inf_ts.push(t); exp_ts.push(&def.typ); } // Remove the type variables of the group from the environment. // This avoids cloning of already generalized types. for name in group.iter() { env.0.remove(name); } // Unify the inferred body with the corresponding type variable. let mut s = ss.into_iter().fold(Subst::default(), |acc, s| acc.compose(s)); let mut ts = vec![]; for ((bod_t, tv), nam) in inf_ts.into_iter().zip(tvs.iter()).zip(group.iter()) { let (t, s2) = unify_term(&tv.subst(&s), &bod_t, &book.defs[nam].rule().body)?; ts.push(t); s = s.compose(s2); } let ts = ts.into_iter().map(|t| t.subst(&s)).collect::>(); // Specialize against the expected type, then generalize and store. for ((name, exp_t), inf_t) in group.iter().zip(exp_ts.iter()).zip(ts.iter()) { let t = specialize(inf_t, exp_t).map_err(|e| { diags.add_function_error(e, name.clone(), book.defs[name].source.clone()); std::mem::take(diags) })?; types.insert(name.clone(), t.generalize(&TypeEnv::default())); } diags.fatal(()) } /// Infer the type of a term in the given environment. /// /// The type environment must contain bindings for all the free variables of the term. /// /// The returned substitution records the type constraints imposed on type variables by the term. /// The returned type is the type of the term. fn infer( env: &mut TypeEnv, book: &Book, types: &ProgramTypes, term: &Term, var_gen: &mut VarGen, ) -> Result<(Subst, Type), String> { let res = maybe_grow(|| match term { Term::Var { nam } | Term::Ref { nam } => { if let Some(scheme) = env.0.get(nam) { Ok::<_, String>((Subst::default(), scheme.instantiate(var_gen))) } else if let Some(scheme) = types.get(nam) { Ok((Subst::default(), scheme.instantiate(var_gen))) } else { unreachable!("unbound name '{}'", nam) } } Term::Lam { tag: Tag::Static, pat, bod } => match pat.as_ref() { Pattern::Var(nam) => { let tv = var_gen.fresh(); let old_bnd = env.add_binds([(nam, Scheme(vec![], tv.clone()))]); let (s, bod_t) = infer(env, book, types, bod, var_gen)?; env.pop_binds(old_bnd); let var_t = tv.subst(&s); Ok((s, Type::Arr(Box::new(var_t), Box::new(bod_t)))) } _ => unreachable!("{}", term), }, Term::App { tag: Tag::Static, fun, arg } => { let (s1, fun_t) = infer(env, book, types, fun, var_gen)?; let (s2, arg_t) = infer(&mut env.subst(&s1), book, types, arg, var_gen)?; let app_t = var_gen.fresh(); let (_, s3) = unify_term(&fun_t.subst(&s2), &Type::Arr(Box::new(arg_t), Box::new(app_t.clone())), fun)?; let t = app_t.subst(&s3); Ok((s3.compose(s2).compose(s1), t)) } Term::Let { pat, val, nxt } => match pat.as_ref() { Pattern::Var(nam) => { let (s1, val_t) = infer(env, book, types, val, var_gen)?; let old_bnd = env.add_binds([(nam, val_t.generalize(&env.subst(&s1)))]); let (s2, nxt_t) = infer(&mut env.subst(&s1), book, types, nxt, var_gen)?; env.pop_binds(old_bnd); Ok((s2.compose(s1), nxt_t)) } Pattern::Fan(FanKind::Tup, Tag::Static, _) => { // Tuple elimination behaves like pattern matching. // Variables from tuple patterns don't get generalized. debug_assert!(!(pat.has_unscoped() || pat.has_nested())); let (s1, val_t) = infer(env, book, types, val, var_gen)?; let tvs = pat.binds().map(|_| var_gen.fresh()).collect::>(); let old_bnd = env.add_binds(pat.binds().zip(tvs.iter().map(|tv| Scheme(vec![], tv.clone())))); let (s2, nxt_t) = infer(&mut env.subst(&s1), book, types, nxt, var_gen)?; env.pop_binds(old_bnd); let tvs = tvs.into_iter().map(|tv| tv.subst(&s2)).collect::>(); let (_, s3) = unify_term(&val_t, &Type::Tup(tvs), val)?; Ok((s3.compose(s2).compose(s1), nxt_t)) } Pattern::Fan(FanKind::Dup, Tag::Auto, _) => { // We pretend that sups don't exist and dups don't collide. // All variables must have the same type as the body of the dup. debug_assert!(!(pat.has_unscoped() || pat.has_nested())); let (s1, mut val_t) = infer(env, book, types, val, var_gen)?; let tvs = pat.binds().map(|_| var_gen.fresh()).collect::>(); let old_bnd = env.add_binds(pat.binds().zip(tvs.iter().map(|tv| Scheme(vec![], tv.clone())))); let (mut s2, nxt_t) = infer(&mut env.subst(&s1), book, types, nxt, var_gen)?; env.pop_binds(old_bnd); for tv in tvs { let (val_t_, s) = unify_term(&val_t, &tv.subst(&s2), val)?; val_t = val_t_; s2 = s2.compose(s); } Ok((s2.compose(s1), nxt_t)) } _ => unreachable!(), }, Term::Mat { bnd: _, arg, with_bnd: _, with_arg: _, arms } => { // Infer type of the scrutinee let (s1, t1) = infer(env, book, types, arg, var_gen)?; // Instantiate the expected type of the scrutinee let adt_name = book.ctrs.get(arms[0].0.as_ref().unwrap()).unwrap(); let adt = &book.adts[adt_name]; let (adt_s, adt_t) = instantiate_adt(adt, var_gen)?; // For each case, infer the types and unify them all. // Unify the inferred type of the destructured fields with the // expected from what we inferred from the scrutinee. let (s2, nxt_t) = infer_match_cases(env.subst(&s1), book, types, adt, arms, &adt_s, var_gen)?; // Unify the inferred type with the expected type let (_, s3) = unify_term(&t1, &adt_t.subst(&s2), arg)?; Ok((s3.compose(s2).compose(s1), nxt_t)) } Term::Num { val } => { let t = match val { Num::U24(_) => Type::U24, Num::I24(_) => Type::I24, Num::F24(_) => Type::F24, }; Ok((Subst::default(), t)) } Term::Oper { opr, fst, snd } => { let (s1, t1) = infer(env, book, types, fst, var_gen)?; let (s2, t2) = infer(&mut env.subst(&s1), book, types, snd, var_gen)?; let (t2, s3) = unify_term(&t2.subst(&s1), &t1.subst(&s2), term)?; let s_args = s3.compose(s2).compose(s1); let t_args = t2.subst(&s_args); // Check numeric type matches the operation let tv = var_gen.fresh(); let (t_opr, s_opr) = match opr { // Any numeric type Op::ADD | Op::SUB | Op::MUL | Op::DIV => { unify_term(&t_args, &Type::Number(Box::new(tv.clone())), term)? } Op::EQ | Op::NEQ | Op::LT | Op::GT | Op::GE | Op::LE => { let (_, s) = unify_term(&t_args, &Type::Number(Box::new(tv.clone())), term)?; (Type::U24, s) } // Integers Op::REM | Op::AND | Op::OR | Op::XOR | Op::SHL | Op::SHR => { unify_term(&t_args, &Type::Integer(Box::new(tv.clone())), term)? } // Floating Op::POW => unify_term(&t_args, &Type::F24, term)?, }; let t = t_opr.subst(&s_opr); Ok((s_opr.compose(s_args), t)) } Term::Swt { bnd: _, arg, with_bnd: _, with_arg: _, pred, arms } => { let (s1, t1) = infer(env, book, types, arg, var_gen)?; let (_, s2) = unify_term(&t1, &Type::U24, arg)?; let s_arg = s2.compose(s1); let mut env = env.subst(&s_arg); let mut ss_nums = vec![]; let mut ts_nums = vec![]; for arm in arms.iter().rev().skip(1) { let (s, t) = infer(&mut env, book, types, arm, var_gen)?; env = env.subst(&s); ss_nums.push(s); ts_nums.push(t); } let old_bnd = env.add_binds([(pred, Scheme(vec![], Type::U24))]); let (s_succ, t_succ) = infer(&mut env, book, types, &arms[1], var_gen)?; env.pop_binds(old_bnd); let s_arms = ss_nums.into_iter().fold(s_succ, |acc, s| acc.compose(s)); let mut t_swt = t_succ; let mut s_swt = Subst::default(); for t_num in ts_nums { let (t, s) = unify_term(&t_swt, &t_num, term)?; t_swt = t; s_swt = s.compose(s_swt); } let s = s_swt.compose(s_arms).compose(s_arg); let t = t_swt.subst(&s); Ok((s, t)) } Term::Fan { fan: FanKind::Tup, tag: Tag::Static, els } => { let res = els.iter().map(|el| infer(env, book, types, el, var_gen)).collect::, _>>()?; let (ss, ts): (Vec, Vec) = res.into_iter().unzip(); let t = Type::Tup(ts); let s = ss.into_iter().fold(Subst::default(), |acc, s| acc.compose(s)); Ok((s, t)) } Term::Era => Ok((Subst::default(), Type::None)), Term::Fan { .. } | Term::Lam { tag: _, .. } | Term::App { tag: _, .. } | Term::Link { .. } => { unreachable!("'{term}' while type checking. Should never occur in checked functions") } Term::Use { .. } | Term::With { .. } | Term::Ask { .. } | Term::Nat { .. } | Term::Str { .. } | Term::List { .. } | Term::Fold { .. } | Term::Bend { .. } | Term::Open { .. } | Term::Def { .. } | Term::Err => unreachable!("'{term}' while type checking. Should have been removed in earlier pass"), })?; Ok(res) } /// Instantiates the type constructor of an ADT, also returning the /// ADT var to instantiated var substitution, to be used when /// instantiating the types of the fields of the eliminated constructors. fn instantiate_adt(adt: &Adt, var_gen: &mut VarGen) -> Result<(Subst, Type), String> { let tvs = adt.vars.iter().map(|_| var_gen.fresh()); let s = Subst(adt.vars.iter().zip(tvs).map(|(x, t)| (x.clone(), t)).collect()); let t = Type::Ctr(adt.name.clone(), adt.vars.iter().cloned().map(Type::Var).collect()); let t = t.subst(&s); Ok((s, t)) } fn infer_match_cases( mut env: TypeEnv, book: &Book, types: &ProgramTypes, adt: &Adt, arms: &[MatchRule], adt_s: &Subst, var_gen: &mut VarGen, ) -> Result<(Subst, Type), String> { maybe_grow(|| { if let Some(((ctr_nam, vars, bod), rest)) = arms.split_first() { let ctr = &adt.ctrs[ctr_nam.as_ref().unwrap()]; // One fresh var per field, we later unify with the expected type. let tvs = vars.iter().map(|_| var_gen.fresh()).collect::>(); // Infer the body and unify the inferred field types with the expected. let old_bnd = env.add_binds(vars.iter().zip(tvs.iter().map(|tv| Scheme(vec![], tv.clone())))); let (s1, t1) = infer(&mut env, book, types, bod, var_gen)?; env.pop_binds(old_bnd); let inf_ts = tvs.into_iter().map(|tv| tv.subst(&s1)).collect::>(); let exp_ts = ctr.fields.iter().map(|f| f.typ.subst(adt_s)).collect::>(); let s2 = unify_fields(inf_ts.iter().zip(exp_ts.iter()), bod)?; // Recurse and unify with the other arms. let s = s2.compose(s1); let (s_rest, t_rest) = infer_match_cases(env.subst(&s), book, types, adt, rest, adt_s, var_gen)?; let (t_final, s_final) = unify_term(&t1.subst(&s), &t_rest, bod)?; Ok((s_final.compose(s_rest).compose(s), t_final)) } else { Ok((Subst::default(), var_gen.fresh())) } }) } fn unify_fields<'a>(ts: impl Iterator, ctx: &Term) -> Result { let ss = ts.map(|(inf, exp)| unify_term(inf, exp, ctx)).collect::, _>>()?; let mut s = Subst::default(); for (_, s2) in ss.into_iter().rev() { s = s.compose(s2); } Ok(s) } fn unify_term(t1: &Type, t2: &Type, ctx: &Term) -> Result<(Type, Subst), String> { match unify(t1, t2) { Ok((t, s)) => Ok((t, s)), Err(msg) => Err(format!("In {ctx}:\n Can't unify '{t1}' and '{t2}'.{msg}")), } } fn unify(t1: &Type, t2: &Type) -> Result<(Type, Subst), String> { maybe_grow(|| match (t1, t2) { (t, Type::Hole) | (Type::Hole, t) => Ok((t.clone(), Subst::default())), (t, Type::Var(x)) | (Type::Var(x), t) => { // Try to bind variable `x` to `t` if let Type::Var(y) = t { if y == x { // Don't bind a variable to itself return Ok((t.clone(), Subst::default())); } } // Occurs check if t.free_type_vars().contains(x) { return Err(format!(" Variable '{x}' occurs in '{t}'")); } Ok((t.clone(), Subst(BTreeMap::from([(x.clone(), t.clone())])))) } (Type::Arr(l1, r1), Type::Arr(l2, r2)) => { let (t1, s1) = unify(l1, l2)?; let (t2, s2) = unify(&r1.subst(&s1), &r2.subst(&s1))?; Ok((Type::Arr(Box::new(t1), Box::new(t2)), s2.compose(s1))) } (Type::Ctr(name1, ts1), Type::Ctr(name2, ts2)) if name1 == name2 && ts1.len() == ts2.len() => { let mut s = Subst::default(); let mut ts = vec![]; for (t1, t2) in ts1.iter().zip(ts2.iter()) { let (t, s2) = unify(t1, t2)?; ts.push(t); s = s.compose(s2); } Ok((Type::Ctr(name1.clone(), ts), s)) } (Type::Tup(els1), Type::Tup(els2)) if els1.len() == els2.len() => { let mut s = Subst::default(); let mut ts = vec![]; for (t1, t2) in els1.iter().zip(els2.iter()) { let (t, s2) = unify(t1, t2)?; ts.push(t); s = s.compose(s2); } Ok((Type::Tup(ts), s)) } t @ ((Type::U24, Type::U24) | (Type::F24, Type::F24) | (Type::I24, Type::I24) | (Type::None, Type::None)) => Ok((t.0.clone(), Subst::default())), (Type::Number(t1), Type::Number(t2)) => { let (t, s) = unify(t1, t2)?; Ok((Type::Number(Box::new(t)), s)) } (Type::Number(tn), Type::Integer(ti)) | (Type::Integer(ti), Type::Number(tn)) => { let (t, s) = unify(ti, tn)?; Ok((Type::Integer(Box::new(t)), s)) } (Type::Integer(t1), Type::Integer(t2)) => { let (t, s) = unify(t1, t2)?; Ok((Type::Integer(Box::new(t)), s)) } (Type::Number(t1) | Type::Integer(t1), t2 @ (Type::U24 | Type::I24 | Type::F24)) | (t2 @ (Type::U24 | Type::I24 | Type::F24), Type::Number(t1) | Type::Integer(t1)) => { let (t, s) = unify(t1, t2)?; Ok((t, s)) } (Type::Any, t) | (t, Type::Any) => { let mut s = Subst::default(); // Recurse to assign variables to `Any` as well for child in t.children() { let (_, s2) = unify(&Type::Any, child)?; s = s2.compose(s); } Ok((Type::Any, s)) } _ => Err(String::new()), }) } /// Specializes the inferred type against the type annotation. /// This way, the annotation can be less general than the inferred type. /// /// It also forces inferred 'Any' to the annotated, inferred types to /// annotated 'Any' and fills 'Hole' with the inferred type. /// /// Errors if the first type is not a superset of the second type. fn specialize(inf: &Type, ann: &Type) -> Result { fn merge_specialization(inf: &Type, exp: &Type, s: &mut Subst) -> Result { maybe_grow(|| match (inf, exp) { // These rules have to come before (t, Type::Hole) => Ok(t.clone()), (Type::Hole, _) => unreachable!("Hole should never appear in the inferred type"), (_inf, Type::Any) => Ok(Type::Any), (Type::Any, exp) => Ok(exp.clone()), (Type::Var(x), new) => { if let Some(old) = s.0.get(x) { if old == new { Ok(new.clone()) } else { Err(format!(" Inferred type variable '{x}' must be both '{old}' and '{new}'")) } } else { s.0.insert(x.clone(), new.clone()); Ok(new.clone()) } } (Type::Arr(l1, r1), Type::Arr(l2, r2)) => { let l = merge_specialization(l1, l2, s)?; let r = merge_specialization(r1, r2, s)?; Ok(Type::Arr(Box::new(l), Box::new(r))) } (Type::Ctr(name1, ts1), Type::Ctr(name2, ts2)) if name1 == name2 && ts1.len() == ts2.len() => { let mut ts = vec![]; for (t1, t2) in ts1.iter().zip(ts2.iter()) { let t = merge_specialization(t1, t2, s)?; ts.push(t); } Ok(Type::Ctr(name1.clone(), ts)) } (Type::Tup(ts1), Type::Tup(ts2)) if ts1.len() == ts2.len() => { let mut ts = vec![]; for (t1, t2) in ts1.iter().zip(ts2.iter()) { let t = merge_specialization(t1, t2, s)?; ts.push(t); } Ok(Type::Tup(ts)) } (Type::Number(t1), Type::Number(t2)) => Ok(Type::Number(Box::new(merge_specialization(t1, t2, s)?))), (Type::Integer(t1), Type::Integer(t2)) => Ok(Type::Integer(Box::new(merge_specialization(t1, t2, s)?))), (Type::U24, Type::U24) | (Type::F24, Type::F24) | (Type::I24, Type::I24) | (Type::None, Type::None) => { Ok(inf.clone()) } _ => Err(String::new()), }) } // Refresh the variable names to avoid conflicts when unifying // Names of type vars in the annotation have nothing to do with names in the inferred type. let var_gen = &mut VarGen::default(); let inf2 = inf.generalize(&TypeEnv::default()).instantiate(var_gen); let ann2 = ann.generalize(&TypeEnv::default()).instantiate(var_gen); let (t, s) = unify(&inf2, &ann2) .map_err(|e| format!("Type Error: Expected function type '{ann}' but found '{inf}'.{e}"))?; let t = t.subst(&s); // Merge the inferred specialization with the expected type. // This is done to cast to/from `Any` and `_` types. let mut merge_s = Subst::default(); let t2 = merge_specialization(&t, ann, &mut merge_s).map_err(|e| { format!("Type Error: Annotated type '{ann}' is not a subtype of inferred type '{inf2}'.{e}") })?; Ok(t2.subst(&merge_s)) } impl std::fmt::Display for Subst { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { writeln!(f, "Subst {{")?; for (x, y) in &self.0 { writeln!(f, " {x} => {y},")?; } write!(f, "}}") } } ================================================ FILE: src/fun/check/unbound_refs.rs ================================================ use crate::{ diagnostics::Diagnostics, fun::{Book, Ctx, Name, Term}, maybe_grow, }; use std::collections::HashSet; impl Ctx<'_> { pub fn check_unbound_refs(&mut self) -> Result<(), Diagnostics> { for def in self.book.defs.values() { let mut unbounds = HashSet::new(); for rule in def.rules.iter() { rule.body.check_unbound_refs(self.book, &mut unbounds); } for unbound in unbounds { self.info.add_function_error( format!("Reference to undefined function '{unbound}'"), def.name.clone(), def.source.clone(), ); } } self.info.fatal(()) } } impl Term { pub fn check_unbound_refs(&self, book: &Book, unbounds: &mut HashSet) { maybe_grow(|| { if let Term::Ref { nam } = self { if !(book.defs.contains_key(nam) || book.hvm_defs.contains_key(nam)) { unbounds.insert(nam.clone()); } } for child in self.children() { child.check_unbound_refs(book, unbounds); } }) } } ================================================ FILE: src/fun/check/unbound_vars.rs ================================================ use crate::{ diagnostics::Diagnostics, fun::{transform::desugar_bend, Ctx, Name, Pattern, Term}, maybe_grow, }; use std::collections::HashMap; #[derive(Debug, Clone)] pub enum UnboundVarErr { Local(Name), Global { var: Name, declared: usize, used: usize }, } impl Ctx<'_> { /// Checks that there are no unbound variables in all definitions. pub fn check_unbound_vars(&mut self) -> Result<(), Diagnostics> { for (def_name, def) in self.book.defs.iter_mut() { let mut errs = Vec::new(); for rule in &mut def.rules { // Note: Using a Vec instead of a Map is a deliberate optimization. let mut scope = rule.pats.iter().flat_map(|pat| pat.binds()).map(|x| x.as_ref()).collect::>(); rule.body.check_unbound_vars(&mut scope, &mut errs); } for err in errs { self.info.add_function_error(err, def_name.clone(), def.source.clone()); } } self.info.fatal(()) } } impl Term { /// Checks that all variables are bound. /// Precondition: References have been resolved, implicit binds have been solved. pub fn check_unbound_vars<'a>( &'a mut self, scope: &mut Vec>, errs: &mut Vec, ) { let mut globals = HashMap::new(); check_uses(self, scope, &mut globals, errs); // Check global vars for (nam, (declared, used)) in globals.into_iter().filter(|(_, (d, u))| !(*d == 1 && *u == 1)) { errs.push(UnboundVarErr::Global { var: nam.clone(), declared, used }); } } } /// Scope has the number of times a name was declared in the current scope /// Globals has how many times a global var name was declared and used. pub fn check_uses<'a>( term: &'a mut Term, scope: &mut Vec>, globals: &mut HashMap, errs: &mut Vec, ) { maybe_grow(move || match term { Term::Var { nam } => { if !scope_contains(nam, scope) { errs.push(UnboundVarErr::Local(nam.clone())); *term = Term::Err; } } Term::Link { nam } => { globals.entry(nam.clone()).or_default().1 += 1; } _ => { if let Some(pat) = term.pattern() { check_global_binds(pat, globals) } for (child, binds) in term.children_mut_with_binds() { for bind in binds.clone() { scope.push(bind.as_ref()); } check_uses(child, scope, globals, errs); for _ in binds { scope.pop(); } } } }) } pub fn check_global_binds(pat: &Pattern, globals: &mut HashMap) { match pat { Pattern::Chn(nam) => { globals.entry(nam.clone()).or_default().0 += 1; } _ => { for child in pat.children() { check_global_binds(child, globals) } } } } fn scope_contains(nam: &Name, scope: &[Option<&Name>]) -> bool { scope.iter().rev().any(|scope_nam| scope_nam == nam) } impl std::fmt::Display for UnboundVarErr { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { UnboundVarErr::Local(var) => { if var == desugar_bend::RECURSIVE_KW { write!( f, "Unbound variable '{}'.\n Note: '{}' is only a keyword inside the 'when' arm of a 'bend'.", var, desugar_bend::RECURSIVE_KW ) } else if let Some((pre, suf)) = var.rsplit_once('-') { write!( f, "Unbound variable '{var}'. If you wanted to subtract '{pre}' from '{suf}', you must separate it with spaces ('{pre} - {suf}') since '-' is a valid name character." ) } else { write!(f, "Unbound variable '{var}'.") } } UnboundVarErr::Global { var, declared, used } => match (declared, used) { (0, _) => write!(f, "Unbound unscoped variable '${var}'."), (_, 0) => write!(f, "Unscoped variable from lambda 'λ${var}' is never used."), (1, _) => write!(f, "Unscoped variable '${var}' used more than once."), (_, 1) => write!(f, "Unscoped lambda 'λ${var}' declared more than once."), (_, _) => { write!(f, "Unscoped lambda 'λ${var}' and unscoped variable '${var}' used more than once.") } }, } } } ================================================ FILE: src/fun/display.rs ================================================ use super::{Book, Definition, FanKind, Name, Num, Op, Pattern, Rule, Tag, Term, Type}; use crate::maybe_grow; use std::{fmt, ops::Deref, sync::atomic::AtomicU64}; /* Some aux structures for things that are not so simple to display */ pub struct DisplayFn fmt::Result>(pub F); impl fmt::Result> fmt::Display for DisplayFn { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { self.0(f) } } pub struct DisplayJoin(pub F, pub S); impl fmt::Display for DisplayJoin where F: (Fn() -> I), I: IntoIterator, I::Item: fmt::Display, S: fmt::Display, { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { for (i, x) in self.0().into_iter().enumerate() { if i != 0 { self.1.fmt(f)?; } x.fmt(f)?; } Ok(()) } } macro_rules! display { ($($x:tt)*) => { DisplayFn(move |f| write!(f, $($x)*)) }; } /* The actual display implementations */ static NAMEGEN: AtomicU64 = AtomicU64::new(0); fn gen_fan_pat_name() -> Name { let n = NAMEGEN.fetch_add(1, std::sync::atomic::Ordering::SeqCst); Name::new(format!("pat%{}", super::num_to_name(n))) } fn namegen_reset() { NAMEGEN.store(0, std::sync::atomic::Ordering::SeqCst); } impl fmt::Display for Term { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { maybe_grow(|| match self { Term::Lam { tag, pat, bod } => match &**pat { Pattern::Fan(_, _, _) => { let name = gen_fan_pat_name(); write!(f, "{}λ{name} let {} = {name}; {}", tag.display_padded(), pat, bod) } _ => write!(f, "{}λ{} {}", tag.display_padded(), pat, bod), }, Term::Var { nam } => write!(f, "{nam}"), Term::Link { nam } => write!(f, "${nam}"), Term::Let { pat, val, nxt } => write!(f, "let {} = {}; {}", pat, val, nxt), Term::With { typ, bod } => write!(f, "with {typ} {{ {bod} }}"), Term::Ask { pat, val, nxt } => write!(f, "ask {pat} = {val}; {nxt}"), Term::Use { nam, val, nxt } => { let Some(nam) = nam else { unreachable!() }; write!(f, "use {} = {}; {}", nam, val, nxt) } Term::Ref { nam: def_name } => write!(f, "{def_name}"), Term::App { tag, fun, arg } => { write!(f, "{}({} {})", tag.display_padded(), fun.display_app(tag), arg) } Term::Mat { arg, bnd, with_bnd, with_arg, arms } => { write!(f, "match ")?; if let Some(bnd) = bnd { write!(f, "{} = ", bnd)?; } write!(f, "{} ", arg)?; if !with_bnd.is_empty() { write!(f, "with ")?; for (bnd, arg) in with_bnd.iter().zip(with_arg.iter()) { write!(f, "{} = {}, ", var_as_str(bnd), arg)?; } } write!(f, "{{ ")?; for arm in arms { write!(f, "{}", var_as_str(&arm.0))?; for var in &arm.1 { write!(f, " {}", var_as_str(var))?; } write!(f, ": {}; ", arm.2)?; } write!(f, "}}") } Term::Swt { arg, bnd, with_bnd, with_arg, pred, arms } => { write!(f, "switch ")?; if let Some(bnd) = bnd { write!(f, "{bnd} = ")?; } write!(f, "{arg} ")?; if !with_bnd.is_empty() { write!(f, "with ")?; for (bnd, arg) in with_bnd.iter().zip(with_arg.iter()) { write!(f, "{} = {}, ", var_as_str(bnd), arg)?; } } write!(f, "{{ ")?; for (i, arm) in arms.iter().enumerate() { if i == arms.len() - 1 { write!(f, "_")?; if let Some(pred) = pred { write!(f, " {pred}")?; } } else { write!(f, "{i}")?; } write!(f, ": {arm}; ")?; } write!(f, "}}") } Term::Fold { bnd, arg, with_bnd, with_arg, arms } => { write!(f, "fold ")?; if let Some(bnd) = bnd { write!(f, "{} = ", bnd)?; } write!(f, "{} ", arg)?; if !with_bnd.is_empty() { write!(f, "with ")?; for (bnd, arg) in with_bnd.iter().zip(with_arg.iter()) { write!(f, "{} = {}, ", var_as_str(bnd), arg)?; } } write!(f, "{{ ")?; for arm in arms { write!(f, "{}", var_as_str(&arm.0))?; for var in &arm.1 { write!(f, " {}", var_as_str(var))?; } write!(f, ": {}; ", arm.2)?; } write!(f, "}}") } Term::Bend { bnd: bind, arg: init, cond, step, base } => { write!(f, "bend ")?; for (bind, init) in bind.iter().zip(init) { if let Some(bind) = bind { write!(f, "{} = ", bind)?; } write!(f, "{}, ", init)?; } write!(f, "{{ when {cond}: {step}; else: {base} }}") } Term::Fan { fan: FanKind::Tup, tag, els } => write!(f, "{}({})", tag, DisplayJoin(|| els.iter(), ", ")), Term::Fan { fan: FanKind::Dup, tag, els } => write!(f, "{}{{{}}}", tag, DisplayJoin(|| els, " ")), Term::Era => write!(f, "*"), Term::Num { val: Num::U24(val) } => write!(f, "{val}"), Term::Num { val: Num::I24(val) } => write!(f, "{}{}", if *val < 0 { "-" } else { "+" }, val.abs()), Term::Num { val: Num::F24(val) } => write!(f, "{val:.3}"), Term::Nat { val } => write!(f, "#{val}"), Term::Str { val } => write!(f, "{val:?}"), Term::Oper { opr, fst, snd } => { write!(f, "({} {} {})", opr, fst, snd) } Term::List { els } => write!(f, "[{}]", DisplayJoin(|| els.iter(), ", "),), Term::Open { typ, var, bod } => write!(f, "open {typ} {var}; {bod}"), Term::Def { def, nxt } => { write!(f, "def ")?; for rule in def.rules.iter() { write!(f, "{}", rule.display(&def.name))?; } write!(f, "{nxt}") } Term::Err => write!(f, ""), }) } } impl fmt::Display for Tag { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Tag::Named(name) => write!(f, "#{name}"), Tag::Numeric(num) => write!(f, "#{num}"), Tag::Auto => Ok(()), Tag::Static => Ok(()), } } } impl fmt::Display for Pattern { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Pattern::Var(None) => write!(f, "*"), Pattern::Var(Some(nam)) => write!(f, "{nam}"), Pattern::Chn(nam) => write!(f, "${nam}"), Pattern::Ctr(nam, pats) => { write!(f, "({}{})", nam, DisplayJoin(|| pats.iter().map(|p| display!(" {p}")), "")) } Pattern::Num(num) => write!(f, "{num}"), Pattern::Fan(FanKind::Tup, tag, pats) => write!(f, "{}({})", tag, DisplayJoin(|| pats, ", ")), Pattern::Fan(FanKind::Dup, tag, pats) => write!(f, "{}{{{}}}", tag, DisplayJoin(|| pats, " ")), Pattern::Lst(pats) => write!(f, "[{}]", DisplayJoin(|| pats, ", ")), Pattern::Str(str) => write!(f, "\"{str}\""), } } } impl Rule { pub fn display<'a>(&'a self, def_name: &'a Name) -> impl fmt::Display + 'a { display!( "({}{}) = {}", def_name, DisplayJoin(|| self.pats.iter().map(|x| display!(" {x}")), ""), self.body ) } } impl fmt::Display for Definition { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { namegen_reset(); writeln!(f, "{}{}: {}", if !self.check { "unchecked " } else { "" }, self.name, self.typ)?; write!(f, "{}", DisplayJoin(|| self.rules.iter().map(|x| x.display(&self.name)), "\n")) } } impl fmt::Display for Book { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", DisplayJoin(|| self.defs.values(), "\n\n"))?; for def in self.hvm_defs.values() { writeln!(f, "hvm {}:\n{}\n", def.name, def.body.show())?; } Ok(()) } } impl fmt::Display for Name { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { self.0.fmt(f) } } impl Term { fn display_app<'a>(&'a self, tag: &'a Tag) -> impl fmt::Display + 'a { maybe_grow(|| { DisplayFn(move |f| match self { Term::App { tag: tag2, fun, arg } if tag2 == tag => { write!(f, "{} {}", fun.display_app(tag), arg) } _ => write!(f, "{}", self), }) }) } } impl fmt::Display for Op { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Op::ADD => write!(f, "+"), Op::SUB => write!(f, "-"), Op::MUL => write!(f, "*"), Op::DIV => write!(f, "/"), Op::REM => write!(f, "%"), Op::EQ => write!(f, "=="), Op::NEQ => write!(f, "!="), Op::LT => write!(f, "<"), Op::GT => write!(f, ">"), Op::AND => write!(f, "&"), Op::OR => write!(f, "|"), Op::XOR => write!(f, "^"), Op::POW => write!(f, "**"), Op::SHR => write!(f, ">>"), Op::SHL => write!(f, "<<"), Op::LE => write!(f, "<="), Op::GE => write!(f, ">="), } } } impl Tag { pub fn display_padded(&self) -> impl fmt::Display + '_ { DisplayFn(move |f| match self { Tag::Named(name) => write!(f, "#{name} "), Tag::Numeric(num) => write!(f, "#{num} "), Tag::Auto => Ok(()), Tag::Static => Ok(()), }) } } impl fmt::Display for Type { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { maybe_grow(|| match self { Type::Hole => write!(f, "_"), Type::Var(nam) => write!(f, "{nam}"), Type::Arr(lft, rgt) => write!(f, "({} -> {})", lft, rgt.display_arrow()), Type::Ctr(nam, args) => { if args.is_empty() { write!(f, "{nam}") } else { write!(f, "({nam} {})", DisplayJoin(|| args.iter(), " ")) } } Type::Number(t) => write!(f, "(Number {t})"), Type::Integer(t) => write!(f, "(Integer {t})"), Type::U24 => write!(f, "u24"), Type::I24 => write!(f, "i24"), Type::F24 => write!(f, "f24"), Type::Any => write!(f, "Any"), Type::None => write!(f, "None"), Type::Tup(els) => write!(f, "({})", DisplayJoin(|| els.iter(), ", ")), }) } } impl Type { pub fn display_arrow(&self) -> impl fmt::Display + '_ { maybe_grow(|| { DisplayFn(move |f| match self { Type::Arr(lft, rgt) => { write!(f, "{} -> {}", lft, rgt.display_arrow()) } _ => write!(f, "{}", self), }) }) } } fn var_as_str(nam: &Option) -> &str { nam.as_ref().map_or("*", Name::deref) } /* Pretty printing */ impl Book { pub fn display_pretty(&self) -> impl fmt::Display + '_ { display!( "{}\n{}", DisplayJoin(|| self.defs.values().map(|def| def.display_pretty()), "\n\n"), DisplayJoin( || self.hvm_defs.values().map(|def| display!("hvm {}:\n{}", def.name, def.body.show())), "\n" ) ) } } impl Definition { pub fn display_pretty(&self) -> impl fmt::Display + '_ { namegen_reset(); display!("{}", DisplayJoin(|| self.rules.iter().map(|x| x.display_pretty(&self.name)), "\n")) } } impl Rule { pub fn display_pretty<'a>(&'a self, def_name: &'a Name) -> impl fmt::Display + 'a { display!( "({}{}) =\n {}", def_name, DisplayJoin(|| self.pats.iter().map(|x| display!(" {x}")), ""), self.body.display_pretty(2) ) } pub fn display_def_aux<'a>(&'a self, def_name: &'a Name, tab: usize) -> impl fmt::Display + 'a { display!( "({}{}) =\n {:tab$}{}", def_name, DisplayJoin(|| self.pats.iter().map(|x| display!(" {x}")), ""), "", self.body.display_pretty(tab + 2) ) } } impl Term { pub fn display_pretty(&self, tab: usize) -> impl fmt::Display + '_ { maybe_grow(|| { DisplayFn(move |f| match self { Term::Lam { tag, pat, bod } => match &**pat { Pattern::Fan(_, _, _) => { let name = gen_fan_pat_name(); write!( f, "{}λ{name} let {} = {name};\n{:tab$}{}", tag.display_padded(), pat, "", bod.display_pretty(tab), ) } _ => write!(f, "{}λ{} {}", tag.display_padded(), pat, bod.display_pretty(tab)), }, Term::Var { nam } => write!(f, "{nam}"), Term::Link { nam } => write!(f, "${nam}"), Term::Let { pat, val, nxt } => { write!(f, "let {} = {};\n{:tab$}{}", pat, val.display_pretty(tab), "", nxt.display_pretty(tab)) } Term::With { typ, bod } => { writeln!(f, "with {typ} {{")?; writeln!(f, "{:tab$}{}", "", bod.display_pretty(tab + 2), tab = tab + 2)?; write!(f, "{:tab$}}}", "") } Term::Ask { pat, val, nxt } => { write!(f, "ask {} = {};\n{:tab$}{}", pat, val.display_pretty(tab), "", nxt.display_pretty(tab)) } Term::Use { nam, val, nxt } => { write!( f, "use {} = {};\n{:tab$}{}", var_as_str(nam), val.display_pretty(tab), "", nxt.display_pretty(tab) ) } Term::App { tag, fun, arg } => { write!( f, "{}({} {})", tag.display_padded(), fun.display_app_pretty(tag, tab), arg.display_pretty(tab) ) } Term::Fan { fan: FanKind::Tup, tag, els } => { write!(f, "{}({})", tag, DisplayJoin(|| els.iter().map(|e| e.display_pretty(tab)), ", ")) } Term::Fan { fan: FanKind::Dup, tag, els } => { write!( f, "{}{{{}}}", tag.display_padded(), DisplayJoin(|| els.iter().map(|e| e.display_pretty(tab)), " ") ) } Term::List { els } => { write!(f, "[{}]", DisplayJoin(|| els.iter().map(|e| e.display_pretty(tab)), " ")) } Term::Oper { opr, fst, snd } => { write!(f, "({} {} {})", opr, fst.display_pretty(tab), snd.display_pretty(tab)) } Term::Mat { bnd, arg, with_bnd, with_arg, arms } => { write!(f, "match ")?; if let Some(bnd) = bnd { write!(f, "{} = ", bnd)?; } write!(f, "{} ", arg.display_pretty(tab))?; if !with_bnd.is_empty() { write!(f, "with ")?; for (bnd, arg) in with_bnd.iter().zip(with_arg.iter()) { write!(f, "{} = {}, ", var_as_str(bnd), arg)?; } } write!(f, "{{ ")?; for arm in arms { write!(f, "\n{:tab$}{}", "", var_as_str(&arm.0), tab = tab + 2)?; for var in &arm.1 { write!(f, " {}", var_as_str(var))?; } write!(f, ": {}; ", arm.2.display_pretty(tab + 4))?; } write!(f, "\n{:tab$}}}", "") } Term::Swt { bnd, arg, with_bnd, with_arg, pred, arms } => { write!(f, "switch ")?; if let Some(bnd) = bnd { write!(f, "{bnd} = ")?; } write!(f, "{} ", arg.display_pretty(tab))?; if !with_bnd.is_empty() { write!(f, "with ")?; for (bnd, arg) in with_bnd.iter().zip(with_arg.iter()) { write!(f, "{} = {}, ", var_as_str(bnd), arg)?; } } writeln!(f, "{{")?; for (i, arm) in arms.iter().enumerate() { if i == arms.len() - 1 { write!(f, "{:tab$}_", "", tab = tab + 2)?; if let Some(pred) = pred { write!(f, " {pred}")?; } } else { write!(f, "{:tab$}{i}", "", tab = tab + 2)?; } writeln!(f, ": {};", arm.display_pretty(tab + 4))?; } write!(f, "{:tab$}}}", "") } Term::Fold { bnd, arg, with_bnd, with_arg, arms } => { write!(f, "fold ")?; if let Some(bnd) = bnd { write!(f, "{} = ", bnd)?; } write!(f, "{} ", arg.display_pretty(tab))?; if !with_bnd.is_empty() { write!(f, "with ")?; for (bnd, arg) in with_bnd.iter().zip(with_arg.iter()) { write!(f, "{} = {}, ", var_as_str(bnd), arg)?; } } write!(f, "{{ ")?; for arm in arms { write!(f, "\n{:tab$}{}", "", var_as_str(&arm.0), tab = tab + 2)?; for var in &arm.1 { write!(f, " {}", var_as_str(var))?; } write!(f, ": {}; ", arm.2.display_pretty(tab + 4))?; } write!(f, "\n{:tab$}}}", "") } Term::Bend { bnd: bind, arg: init, cond, step, base } => { write!(f, "bend ")?; for (bind, init) in bind.iter().zip(init) { if let Some(bind) = bind { write!(f, "{} = ", bind)?; } write!(f, "{}, ", init)?; } writeln!(f, "{{")?; writeln!(f, "{:tab$}when {}:", "", cond.display_pretty(tab + 2), tab = tab + 2)?; writeln!(f, "{:tab$}{}", "", step.display_pretty(tab + 4), tab = tab + 4)?; writeln!(f, "{:tab$}else:", "", tab = tab + 2)?; writeln!(f, "{:tab$}{}", "", base.display_pretty(tab + 4), tab = tab + 4)?; write!(f, "{:tab$}}}", "") } Term::Open { typ, var, bod } => { write!(f, "open {typ} {var};\n{:tab$}{}", "", bod.display_pretty(tab)) } Term::Nat { val } => write!(f, "#{val}"), Term::Num { val: Num::U24(val) } => write!(f, "{val}"), Term::Num { val: Num::I24(val) } => write!(f, "{}{}", if *val < 0 { "-" } else { "+" }, val.abs()), Term::Num { val: Num::F24(val) } => write!(f, "{val:.3}"), Term::Str { val } => write!(f, "{val:?}"), Term::Ref { nam } => write!(f, "{nam}"), Term::Def { def, nxt } => { write!(f, "def ")?; for (i, rule) in def.rules.iter().enumerate() { if i == 0 { writeln!(f, "{}", rule.display_def_aux(&def.name, tab + 4))?; } else { writeln!(f, "{:tab$}{}", "", rule.display_def_aux(&def.name, tab + 4), tab = tab + 4)?; } } write!(f, "{:tab$}{}", "", nxt.display_pretty(tab)) } Term::Era => write!(f, "*"), Term::Err => write!(f, ""), }) }) } fn display_app_pretty<'a>(&'a self, tag: &'a Tag, tab: usize) -> impl fmt::Display + 'a { maybe_grow(|| { DisplayFn(move |f| match self { Term::App { tag: tag2, fun, arg } if tag2 == tag => { write!(f, "{} {}", fun.display_app_pretty(tag, tab), arg.display_pretty(tab)) } _ => write!(f, "{}", self.display_pretty(tab)), }) }) } } ================================================ FILE: src/fun/load_book.rs ================================================ use super::{ parser::{FunParser, ParseBook}, Book, Name, Source, SourceKind, }; use crate::{ diagnostics::{Diagnostics, DiagnosticsConfig, TextSpan}, imports::PackageLoader, }; use std::path::Path; // TODO: Refactor so that we don't mix the two syntaxes here. /// Reads a file and parses to a definition book. pub fn load_file_to_book( path: &Path, package_loader: impl PackageLoader, diag: DiagnosticsConfig, ) -> Result { match path.try_exists() { Ok(exists) => { if !exists { return Err(format!("The file '{}' was not found.", path.display()).into()); } let code = std::fs::read_to_string(path).map_err(|e| e.to_string())?; load_to_book(path, &code, package_loader, diag) } Err(e) => Err(e.to_string().into()), } } pub fn load_to_book( origin: &Path, code: &str, package_loader: impl PackageLoader, diag: DiagnosticsConfig, ) -> Result { let builtins = ParseBook::builtins(); let book = do_parse_book(code, origin, builtins)?; book.load_imports(package_loader, diag) } pub fn do_parse_book(code: &str, origin: &Path, mut book: ParseBook) -> Result { book.source = Name::new(origin.to_string_lossy()); FunParser::new(book.source.clone(), code, false).parse_book(book).map_err(|err| { let mut diagnostics = Diagnostics::default(); let span = TextSpan::from_byte_span(code, err.span.0..err.span.1); let source = Source { file: Some(origin.to_string_lossy().into()), span: Some(span), kind: SourceKind::User }; diagnostics.add_parsing_error(err, source); diagnostics }) } ================================================ FILE: src/fun/mod.rs ================================================ use crate::{ diagnostics::{Diagnostics, DiagnosticsConfig, TextSpan}, imports::Import, maybe_grow, multi_iterator, ENTRY_POINT, }; use indexmap::{IndexMap, IndexSet}; use interner::global::{GlobalPool, GlobalString}; use itertools::Itertools; use std::{ borrow::Cow, hash::Hash, ops::{Deref, Range}, }; pub mod builtins; pub mod check; pub mod display; pub mod load_book; pub mod net_to_term; pub mod parser; pub mod term_to_net; pub mod transform; pub use net_to_term::{net_to_term, ReadbackError}; pub use term_to_net::{book_to_hvm, term_to_hvm}; pub static STRINGS: GlobalPool = GlobalPool::new(); #[derive(Debug)] pub struct Ctx<'book> { pub book: &'book mut Book, pub info: Diagnostics, } impl Ctx<'_> { pub fn new(book: &mut Book, diagnostics_cfg: DiagnosticsConfig) -> Ctx { Ctx { book, info: Diagnostics::new(diagnostics_cfg) } } } /// The representation of a program. #[derive(Debug, Clone, Default)] pub struct Book { /// Function definitions. pub defs: Definitions, /// HVM native function definitions. pub hvm_defs: HvmDefinitions, /// Algebraic datatype definitions. pub adts: Adts, /// Map of constructor name to type name. pub ctrs: Constructors, /// A custom or default "main" entrypoint. pub entrypoint: Option, /// Imports declared in the program. pub imports: Vec, } pub type Definitions = IndexMap; pub type HvmDefinitions = IndexMap; pub type Adts = IndexMap; pub type Constructors = IndexMap; /// A pattern matching function definition. #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct Definition { pub name: Name, pub typ: Type, pub check: bool, pub rules: Vec, pub source: Source, } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct Source { pub file: Option, pub span: Option, pub kind: SourceKind, } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum SourceKind { /// Built into the language. Builtin, /// Was generated by the compiler. Generated, /// Source code from a local book. User, /// Source code from an imported book. Imported, /// Unknown by the compiler at this stage. Unknown, } /// An HVM native definition. #[derive(Debug, Clone)] pub struct HvmDefinition { pub name: Name, pub typ: Type, pub body: hvm::ast::Net, pub source: Source, } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum Type { Any, Hole, Var(Name), Ctr(Name, Vec), Arr(Box, Box), Tup(Vec), U24, F24, I24, None, Number(Box), Integer(Box), } /// A pattern matching rule of a definition. #[derive(Debug, Clone, Default, PartialEq, Eq, Hash)] pub struct Rule { pub pats: Vec, pub body: Term, } #[derive(Debug, Default, PartialEq, Eq, Hash)] pub enum Term { Lam { tag: Tag, pat: Box, bod: Box, }, Var { nam: Name, }, Link { nam: Name, }, Let { pat: Box, val: Box, nxt: Box, }, With { typ: Name, bod: Box, }, Ask { pat: Box, val: Box, nxt: Box, }, Use { nam: Option, val: Box, nxt: Box, }, App { tag: Tag, fun: Box, arg: Box, }, /// Either a tuple or a superposition Fan { fan: FanKind, tag: Tag, els: Vec, }, Num { val: Num, }, Nat { val: u32, }, Str { val: GlobalString, }, List { els: Vec, }, /// A numeric operation between built-in numbers. Oper { opr: Op, fst: Box, snd: Box, }, /// Pattern matching on an ADT. Mat { bnd: Option, arg: Box, with_bnd: Vec>, with_arg: Vec, arms: Vec, }, /// Native pattern matching on numbers Swt { bnd: Option, arg: Box, with_bnd: Vec>, with_arg: Vec, pred: Option, arms: Vec, }, Fold { bnd: Option, arg: Box, with_bnd: Vec>, with_arg: Vec, arms: Vec, }, Bend { bnd: Vec>, arg: Vec, cond: Box, step: Box, base: Box, }, Open { typ: Name, var: Name, bod: Box, }, Ref { nam: Name, }, Def { def: Definition, nxt: Box, }, Era, #[default] Err, } pub type MatchRule = (Option, Vec>, Term); #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub enum FanKind { Tup, Dup, } #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub enum Op { ADD, SUB, MUL, DIV, REM, EQ, NEQ, LT, GT, AND, OR, XOR, SHL, SHR, // a^b POW, /// Less than or equal LE, /// Greater than or equal GE, } #[derive(Debug, Clone, Copy)] pub enum Num { U24(u32), I24(i32), F24(f32), } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum Pattern { Var(Option), Chn(Name), Ctr(Name, Vec), Num(u32), /// Either a tuple or a duplication Fan(FanKind, Tag, Vec), Lst(Vec), Str(GlobalString), } #[derive(Debug, Clone, PartialEq, Eq, Hash, Default)] pub enum Tag { Named(Name), Numeric(u16), Auto, #[default] Static, } /// A user defined datatype #[derive(Debug, Clone)] pub struct Adt { pub name: Name, pub vars: Vec, pub ctrs: IndexMap, pub source: Source, } #[derive(Debug, Clone)] pub struct AdtCtr { pub name: Name, pub typ: Type, pub fields: Vec, } #[derive(Debug, Clone)] pub struct CtrField { pub nam: Name, pub rec: bool, pub typ: Type, } #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] pub struct Name(GlobalString); /* Implementations */ impl PartialEq for Name { fn eq(&self, other: &str) -> bool { &**self == other } } impl PartialEq<&str> for Name { fn eq(&self, other: &&str) -> bool { self == *other } } impl PartialEq> for Name { fn eq(&self, other: &Option) -> bool { if let Some(other) = other.as_ref() { self == other } else { false } } } impl PartialEq for Option { fn eq(&self, other: &Name) -> bool { other.eq(self) } } impl PartialEq> for Name { fn eq(&self, other: &Option<&Name>) -> bool { if let Some(other) = other { &self == other } else { false } } } impl PartialEq for Option<&Name> { fn eq(&self, other: &Name) -> bool { other.eq(self) } } pub fn num_to_name(mut num: u64) -> String { let mut name = String::new(); loop { let c = (num % 26) as u8 + b'a'; name.push(c as char); num /= 26; if num == 0 { break; } } name } impl Tag { pub fn adt_name(name: &Name) -> Self { Self::Named(name.clone()) } } impl Clone for Term { fn clone(&self) -> Self { maybe_grow(|| match self { Self::Lam { tag, pat, bod } => Self::Lam { tag: tag.clone(), pat: pat.clone(), bod: bod.clone() }, Self::Var { nam } => Self::Var { nam: nam.clone() }, Self::Link { nam } => Self::Link { nam: nam.clone() }, Self::Let { pat, val, nxt } => Self::Let { pat: pat.clone(), val: val.clone(), nxt: nxt.clone() }, Self::With { typ, bod } => Self::With { typ: typ.clone(), bod: bod.clone() }, Self::Ask { pat, val, nxt } => Self::Ask { pat: pat.clone(), val: val.clone(), nxt: nxt.clone() }, Self::Use { nam, val, nxt } => Self::Use { nam: nam.clone(), val: val.clone(), nxt: nxt.clone() }, Self::App { tag, fun, arg } => Self::App { tag: tag.clone(), fun: fun.clone(), arg: arg.clone() }, Self::Fan { fan, tag, els } => Self::Fan { fan: *fan, tag: tag.clone(), els: els.clone() }, Self::Num { val } => Self::Num { val: *val }, Self::Nat { val } => Self::Nat { val: *val }, Self::Str { val } => Self::Str { val: val.clone() }, Self::List { els } => Self::List { els: els.clone() }, Self::Oper { opr, fst, snd } => Self::Oper { opr: *opr, fst: fst.clone(), snd: snd.clone() }, Self::Mat { arg, bnd, with_bnd, with_arg, arms } => Self::Mat { arg: arg.clone(), bnd: bnd.clone(), with_bnd: with_bnd.clone(), with_arg: with_arg.clone(), arms: arms.clone(), }, Self::Swt { arg, bnd, with_bnd, with_arg, pred, arms } => Self::Swt { arg: arg.clone(), bnd: bnd.clone(), with_bnd: with_bnd.clone(), with_arg: with_arg.clone(), pred: pred.clone(), arms: arms.clone(), }, Self::Fold { bnd, arg, with_bnd, with_arg, arms } => Self::Fold { bnd: bnd.clone(), arg: arg.clone(), with_bnd: with_bnd.clone(), with_arg: with_arg.clone(), arms: arms.clone(), }, Self::Bend { bnd: bind, arg: init, cond, step, base } => Self::Bend { bnd: bind.clone(), arg: init.clone(), cond: cond.clone(), step: step.clone(), base: base.clone(), }, Self::Open { typ, var, bod: nxt } => { Self::Open { typ: typ.clone(), var: var.clone(), bod: nxt.clone() } } Self::Ref { nam } => Self::Ref { nam: nam.clone() }, Self::Def { def, nxt } => Self::Def { def: def.clone(), nxt: nxt.clone() }, Self::Era => Self::Era, Self::Err => Self::Err, }) } } impl Drop for Term { fn drop(&mut self) { loop { // Each iteration moves a child with nested nodes to the last child. // When no nested on the left, we can just drop it and they'll be handled // by the special cases; let mut i = self.children_mut().filter(|x| x.children().next().is_some()); // No nested children, just drop everything let Some(b) = i.next() else { break }; // Only one child with nested nodes, move it up to be the new root. // Non-nested (height=0) children are dropped recursively. if { i }.next().is_none() { *self = std::mem::take(b); continue; } // Rotate the tree right: // ```text // a b // / \ / \ // b e -> c a // / \ / \ // c d d e // ``` let tmp = Term::Err; let d = std::mem::replace(b.children_mut().next_back().unwrap(), tmp); let b = std::mem::replace(b, d); let a = std::mem::replace(self, b); let tmp = std::mem::replace(self.children_mut().next_back().unwrap(), a); std::mem::forget(tmp); } } } impl From> for Pattern { fn from(value: Option) -> Self { Pattern::Var(value) } } impl Term { /* Common construction patterns */ /// Lambda with a static tag pub fn lam(pat: Pattern, bod: Term) -> Self { Self::tagged_lam(Tag::Static, pat, bod) } /// Lambda with any tag pub fn tagged_lam(tag: Tag, pat: Pattern, bod: Term) -> Self { Term::Lam { tag, pat: Box::new(pat), bod: Box::new(bod) } } /// Wraps a term in lambdas, so that the outermost lambda is the first given element. /// /// The lambda equivalent of [`Term::call`]. pub fn rfold_lams(term: Term, pats: impl DoubleEndedIterator>) -> Self { pats.into_iter().rfold(term, |bod, nam| Self::lam(Pattern::Var(nam), bod)) } pub fn var_or_era(nam: Option) -> Self { if let Some(nam) = nam { Term::Var { nam } } else { Term::Era } } pub fn app(fun: Term, arg: Term) -> Self { Self::tagged_app(Tag::Static, fun, arg) } pub fn tagged_app(tag: Tag, fun: Term, arg: Term) -> Self { Term::App { tag, fun: Box::new(fun), arg: Box::new(arg) } } /// Make a call term by folding args around a called function term with applications. pub fn call(called: Term, args: impl IntoIterator) -> Self { args.into_iter().fold(called, Term::app) } pub fn tagged_call(tag: Tag, called: Term, args: impl IntoIterator) -> Self { args.into_iter().fold(called, |acc, arg| Term::tagged_app(tag.clone(), acc, arg)) } /// Apply a variable to a term by the var name. pub fn arg_call(fun: Term, arg: Name) -> Self { Term::app(fun, Term::Var { nam: arg }) } pub fn r#ref(name: &str) -> Self { Term::Ref { nam: Name::new(name) } } pub fn str(str: &str) -> Self { Term::Str { val: STRINGS.get(str) } } pub fn sub_num(arg: Term, val: Num) -> Term { if val.is_zero() { arg } else { Term::Oper { opr: Op::SUB, fst: Box::new(arg), snd: Box::new(Term::Num { val }) } } } pub fn add_num(arg: Term, val: Num) -> Term { if val.is_zero() { arg } else { Term::Oper { opr: Op::ADD, fst: Box::new(arg), snd: Box::new(Term::Num { val }) } } } pub fn pattern(&self) -> Option<&Pattern> { match self { Term::Lam { pat, .. } | Term::Let { pat, .. } => Some(pat), _ => None, } } pub fn pattern_mut(&mut self) -> Option<&mut Pattern> { match self { Term::Lam { pat, .. } | Term::Let { pat, .. } => Some(pat), _ => None, } } /* Iterators */ pub fn children(&self) -> impl DoubleEndedIterator + Clone { multi_iterator!(ChildrenIter { Zero, One, Two, Vec, Mat, Swt, Bend, Fold }); match self { Term::Mat { arg, bnd: _, with_bnd: _, with_arg, arms } => { ChildrenIter::Mat([arg.as_ref()].into_iter().chain(with_arg.iter()).chain(arms.iter().map(|r| &r.2))) } Term::Swt { arg, bnd: _, with_bnd: _, with_arg, pred: _, arms } => { ChildrenIter::Swt([arg.as_ref()].into_iter().chain(with_arg.iter()).chain(arms)) } Term::Bend { bnd: _, arg: init, cond, step, base } => { ChildrenIter::Bend(init.iter().chain([cond.as_ref(), step.as_ref(), base.as_ref()])) } Term::Fold { bnd: _, arg, with_bnd: _, with_arg, arms } => { ChildrenIter::Fold([arg.as_ref()].into_iter().chain(with_arg.iter()).chain(arms.iter().map(|r| &r.2))) } Term::Fan { els, .. } | Term::List { els } => ChildrenIter::Vec(els), Term::Let { val: fst, nxt: snd, .. } | Term::Ask { val: fst, nxt: snd, .. } | Term::Use { val: fst, nxt: snd, .. } | Term::App { fun: fst, arg: snd, .. } | Term::Oper { fst, snd, .. } => ChildrenIter::Two([fst.as_ref(), snd.as_ref()]), Term::Lam { bod, .. } | Term::With { bod, .. } | Term::Open { bod, .. } => { ChildrenIter::One([bod.as_ref()]) } Term::Var { .. } | Term::Link { .. } | Term::Num { .. } | Term::Nat { .. } | Term::Str { .. } | Term::Ref { .. } | Term::Def { .. } | Term::Era | Term::Err => ChildrenIter::Zero([]), } } pub fn children_mut(&mut self) -> impl DoubleEndedIterator { multi_iterator!(ChildrenIter { Zero, One, Two, Vec, Mat, Swt, Bend, Fold }); match self { Term::Mat { arg, bnd: _, with_bnd: _, with_arg, arms } => ChildrenIter::Mat( [arg.as_mut()].into_iter().chain(with_arg.iter_mut()).chain(arms.iter_mut().map(|r| &mut r.2)), ), Term::Swt { arg, bnd: _, with_bnd: _, with_arg, pred: _, arms } => { ChildrenIter::Swt([arg.as_mut()].into_iter().chain(with_arg.iter_mut()).chain(arms)) } Term::Bend { bnd: _, arg: init, cond, step, base } => { ChildrenIter::Bend(init.iter_mut().chain([cond.as_mut(), step.as_mut(), base.as_mut()])) } Term::Fold { bnd: _, arg, with_bnd: _, with_arg, arms } => ChildrenIter::Fold( [arg.as_mut()].into_iter().chain(with_arg.iter_mut()).chain(arms.iter_mut().map(|r| &mut r.2)), ), Term::Fan { els, .. } | Term::List { els } => ChildrenIter::Vec(els), Term::Let { val: fst, nxt: snd, .. } | Term::Ask { val: fst, nxt: snd, .. } | Term::Use { val: fst, nxt: snd, .. } | Term::App { fun: fst, arg: snd, .. } | Term::Oper { fst, snd, .. } => ChildrenIter::Two([fst.as_mut(), snd.as_mut()]), Term::Lam { bod, .. } | Term::With { bod, .. } | Term::Open { bod, .. } => { ChildrenIter::One([bod.as_mut()]) } Term::Var { .. } | Term::Link { .. } | Term::Num { .. } | Term::Nat { .. } | Term::Str { .. } | Term::Ref { .. } | Term::Def { .. } | Term::Era | Term::Err => ChildrenIter::Zero([]), } } /// An iterator over the subterms with an iterator over the binds /// introduced by the current term for each subterm. /// /// Must only be called after fix_matches. /// /// Example: A lambda introduces 1 bind for it's only subterm, /// while a let expression introduces 0 binds for the value and /// many binds for the next term. pub fn children_with_binds( &self, ) -> impl DoubleEndedIterator> + Clone)> + Clone { multi_iterator!(ChildrenIter { Zero, One, Two, Vec, Mat, Swt, Bend }); multi_iterator!(BindsIter { Zero, One, Mat, Pat, SwtNum, SwtSucc, Bend }); match self { Term::Mat { arg, bnd, with_bnd, with_arg, arms } | Term::Fold { bnd, arg, with_bnd, with_arg, arms } => { let arg = [(arg.as_ref(), BindsIter::Zero([]))].into_iter(); let with_arg = with_arg.iter().map(|a| (a, BindsIter::Zero([]))); let arms = arms .iter() .map(move |r| (&r.2, BindsIter::Mat([bnd].into_iter().chain(r.1.iter()).chain(with_bnd.iter())))); ChildrenIter::Mat(arg.chain(with_arg).chain(arms)) } Term::Swt { arg, bnd, with_bnd, with_arg, pred, arms } => { let (succ, nums) = arms.split_last().unwrap(); ChildrenIter::Swt( [(arg.as_ref(), BindsIter::Zero([]))] .into_iter() .chain(with_arg.iter().map(|a| (a, BindsIter::Zero([])))) .chain(nums.iter().map(move |x| (x, BindsIter::SwtNum([bnd].into_iter().chain(with_bnd.iter()))))) .chain([(succ, BindsIter::SwtSucc([bnd, pred].into_iter().chain(with_bnd.iter())))]), ) } Term::Bend { bnd: bind, arg: init, cond, step, base } => { ChildrenIter::Bend(init.iter().map(|x| (x, BindsIter::Zero([]))).chain([ (cond.as_ref(), BindsIter::Bend(bind.iter())), (step.as_ref(), BindsIter::Bend(bind.iter())), (base.as_ref(), BindsIter::Bend(bind.iter())), ])) } Term::Fan { els, .. } | Term::List { els } => { ChildrenIter::Vec(els.iter().map(|el| (el, BindsIter::Zero([])))) } Term::Let { pat, val, nxt, .. } | Term::Ask { pat, val, nxt, .. } => { ChildrenIter::Two([(val.as_ref(), BindsIter::Zero([])), (nxt.as_ref(), BindsIter::Pat(pat.binds()))]) } Term::Use { nam, val, nxt, .. } => { ChildrenIter::Two([(val.as_ref(), BindsIter::Zero([])), (nxt.as_ref(), BindsIter::One([nam]))]) } Term::App { fun: fst, arg: snd, .. } | Term::Oper { fst, snd, .. } => { ChildrenIter::Two([(fst.as_ref(), BindsIter::Zero([])), (snd.as_ref(), BindsIter::Zero([]))]) } Term::Lam { pat, bod, .. } => ChildrenIter::One([(bod.as_ref(), BindsIter::Pat(pat.binds()))]), Term::With { bod, .. } => ChildrenIter::One([(bod.as_ref(), BindsIter::Zero([]))]), Term::Var { .. } | Term::Link { .. } | Term::Num { .. } | Term::Nat { .. } | Term::Str { .. } | Term::Ref { .. } | Term::Def { .. } | Term::Era | Term::Err => ChildrenIter::Zero([]), Term::Open { .. } => unreachable!("Open should be removed in earlier pass"), } } /// Must only be called after fix_matches. pub fn children_mut_with_binds( &mut self, ) -> impl DoubleEndedIterator> + Clone)> { multi_iterator!(ChildrenIter { Zero, One, Two, Vec, Mat, Swt, Bend }); multi_iterator!(BindsIter { Zero, One, Mat, SwtNum, SwtSucc, Pat, Bend }); match self { Term::Mat { arg, bnd, with_bnd, with_arg, arms } | Term::Fold { bnd, arg, with_bnd, with_arg, arms } => { let arg = [(arg.as_mut(), BindsIter::Zero([]))].into_iter(); let with_arg = with_arg.iter_mut().map(|a| (a, BindsIter::Zero([]))); let arms = arms .iter_mut() .map(|r| (&mut r.2, BindsIter::Mat([&*bnd].into_iter().chain(r.1.iter()).chain(with_bnd.iter())))); ChildrenIter::Mat(arg.chain(with_arg).chain(arms)) } Term::Swt { arg, bnd, with_bnd, with_arg, pred, arms } => { let (succ, nums) = arms.split_last_mut().unwrap(); ChildrenIter::Swt( [(arg.as_mut(), BindsIter::Zero([]))] .into_iter() .chain(with_arg.iter_mut().map(|a| (a, BindsIter::Zero([])))) .chain( nums.iter_mut().map(|x| (x, BindsIter::SwtNum([&*bnd].into_iter().chain(with_bnd.iter())))), ) .chain([(succ, BindsIter::SwtSucc([&*bnd, &*pred].into_iter().chain(with_bnd.iter())))]), ) } Term::Bend { bnd, arg, cond, step, base } => { ChildrenIter::Bend(arg.iter_mut().map(|x| (x, BindsIter::Zero([]))).chain([ (cond.as_mut(), BindsIter::Bend(bnd.iter())), (step.as_mut(), BindsIter::Bend(bnd.iter())), (base.as_mut(), BindsIter::Bend(bnd.iter())), ])) } Term::Fan { els, .. } | Term::List { els } => { ChildrenIter::Vec(els.iter_mut().map(|el| (el, BindsIter::Zero([])))) } Term::Let { pat, val, nxt, .. } | Term::Ask { pat, val, nxt, .. } => { ChildrenIter::Two([(val.as_mut(), BindsIter::Zero([])), (nxt.as_mut(), BindsIter::Pat(pat.binds()))]) } Term::Use { nam, val, nxt } => { ChildrenIter::Two([(val.as_mut(), BindsIter::Zero([])), (nxt.as_mut(), BindsIter::One([&*nam]))]) } Term::App { fun: fst, arg: snd, .. } | Term::Oper { fst, snd, .. } => { ChildrenIter::Two([(fst.as_mut(), BindsIter::Zero([])), (snd.as_mut(), BindsIter::Zero([]))]) } Term::Lam { pat, bod, .. } => ChildrenIter::One([(bod.as_mut(), BindsIter::Pat(pat.binds()))]), Term::With { bod, .. } => ChildrenIter::One([(bod.as_mut(), BindsIter::Zero([]))]), Term::Var { .. } | Term::Link { .. } | Term::Num { .. } | Term::Nat { .. } | Term::Str { .. } | Term::Ref { .. } | Term::Def { .. } | Term::Era | Term::Err => ChildrenIter::Zero([]), Term::Open { .. } => unreachable!("Open should be removed in earlier pass"), } } /* Common checks and transformations */ /// Substitute the occurrences of a variable in a term with the given term. /// /// Caution: can cause invalid shadowing of variables if used incorrectly. /// Ex: Using subst to beta-reduce `(@a @b a b)` converting it into `@b b`. /// /// NOTE: Expects var bind information to be properly stored in match expressions, /// so it must run AFTER `fix_match_terms`. /// /// NOTE: Since it doesn't (can't) handle `with` clauses in match terms, /// it must be run only AFTER `with` linearization. pub fn subst(&mut self, from: &Name, to: &Term) { maybe_grow(|| { for (child, binds) in self.children_mut_with_binds() { if !binds.flat_map(|b| b.as_ref()).contains(from) { child.subst(from, to); } } }); if let Term::Var { nam } = self { if nam == from { *self = to.clone(); } } } /// Substitute the occurrences of a constructor name with the given name. pub fn subst_ctrs(&mut self, from: &Name, to: &Name) { maybe_grow(|| { for child in self.children_mut() { child.subst_ctrs(from, to); } }); match self { Term::Fold { arms, .. } | Term::Mat { arms, .. } => { for (arm, _, _) in arms { if let Some(nam) = arm { if nam == from { *nam = to.clone(); } } } } Term::Open { typ, .. } => { if typ == from { *typ = to.clone(); } } _ => (), } } /// Substitutes the occurrences of a type constructor in the term with the given name. pub fn subst_type_ctrs(&mut self, from: &Name, to: &Name) { maybe_grow(|| { match self { Term::Def { def, nxt: _ } => { def.typ.subst_ctr(from, to); } Term::With { typ, bod: _ } => { if typ == from { *typ = to.clone(); } } _ => (), } for child in self.children_mut() { child.subst_type_ctrs(from, to); } }); } /// Substitute the occurrence of an unscoped variable with the given term. pub fn subst_unscoped(&mut self, from: &Name, to: &Term) { maybe_grow(|| { // We don't check the unscoped binds because there can be only one bind of an unscoped var. // TODO: potentially there could be some situation where this causes an incorrect program to compile? for child in self.children_mut() { child.subst_unscoped(from, to); } }); if let Term::Link { nam } = self { if nam == from { *self = to.clone(); } } } /// Collects all the free variables that a term has /// and the number of times each var is used pub fn free_vars(&self) -> IndexMap { fn go_term(term: &Term, free_vars: &mut IndexMap) { maybe_grow(|| { if let Term::Var { nam } = term { *free_vars.entry(nam.clone()).or_default() += 1; } for (child, binds) in term.children_with_binds() { let mut new_scope = Default::default(); go_term(child, &mut new_scope); for nam in binds.flatten() { new_scope.shift_remove(nam); } free_vars.extend(new_scope); } }) } let mut free_vars = Default::default(); go_term(self, &mut free_vars); free_vars } /// Returns the set of declared and the set of used unscoped variables pub fn unscoped_vars(&self) -> (IndexSet, IndexSet) { fn go_pat(pat: &Pattern, decls: &mut IndexSet) { maybe_grow(|| { if let Pattern::Chn(name) = pat { decls.insert(name.clone()); } for child in pat.children() { go_pat(child, decls); } }) } fn go_term(term: &Term, decls: &mut IndexSet, uses: &mut IndexSet) { maybe_grow(|| { if let Term::Link { nam } = term { uses.insert(nam.clone()); } if let Some(pat) = term.pattern() { go_pat(pat, decls) } for child in term.children() { go_term(child, decls, uses); } }) } let mut decls = Default::default(); let mut uses = Default::default(); go_term(self, &mut decls, &mut uses); (decls, uses) } pub fn has_unscoped(&self) -> bool { maybe_grow(|| { let mut has_unscoped = match self { Term::Let { pat, .. } if pat.has_unscoped() => true, Term::Link { .. } => true, _ => false, }; for child in self.children() { if has_unscoped { return true; } has_unscoped |= child.has_unscoped() } has_unscoped }) } } impl Num { pub fn is_zero(&self) -> bool { match self { Num::U24(val) => *val == 0, Num::I24(val) => *val == 0, Num::F24(val) => *val == 0.0, } } pub fn to_bits(&self) -> u32 { match self { Num::U24(val) => hvm::hvm::Numb::new_u24(*val).0, Num::I24(val) => hvm::hvm::Numb::new_i24(*val).0, Num::F24(val) => hvm::hvm::Numb::new_f24(*val).0, } } pub fn from_bits(bits: u32) -> Self { match hvm::hvm::Numb::get_typ(&hvm::hvm::Numb(bits)) { hvm::hvm::TY_U24 => Num::U24(hvm::hvm::Numb::get_u24(&hvm::hvm::Numb(bits))), hvm::hvm::TY_I24 => Num::I24(hvm::hvm::Numb::get_i24(&hvm::hvm::Numb(bits))), hvm::hvm::TY_F24 => Num::F24(hvm::hvm::Numb::get_f24(&hvm::hvm::Numb(bits))), _ => unreachable!("Invalid Num bits"), } } } impl Hash for Num { fn hash(&self, state: &mut H) { self.to_bits().hash(state); } } impl PartialEq for Num { fn eq(&self, other: &Self) -> bool { self.to_bits() == other.to_bits() } } impl Eq for Num {} impl Pattern { pub fn binds(&self) -> impl DoubleEndedIterator> + Clone { self.iter().filter_map(|pat| match pat { Pattern::Var(nam) => Some(nam), _ => None, }) } pub fn binds_mut(&mut self) -> impl DoubleEndedIterator> { // Can't have a Pattern::iter_mut() since it has a tree-like structure. let mut binds = vec![]; let mut to_visit = vec![self]; while let Some(pat) = to_visit.pop() { match pat { Pattern::Var(nam) => binds.push(nam), _ => to_visit.extend(pat.children_mut().rev()), } } binds.into_iter() } /// Returns an iterator over each immediate child sub-pattern of `self`. /// Considers Lists as its own pattern and not a sequence of Cons. pub fn children(&self) -> impl DoubleEndedIterator + Clone { multi_iterator!(ChildrenIter { Zero, Vec }); match self { Pattern::Ctr(_, els) | Pattern::Fan(.., els) | Pattern::Lst(els) => ChildrenIter::Vec(els.iter()), Pattern::Var(_) | Pattern::Chn(_) | Pattern::Num(_) | Pattern::Str(_) => ChildrenIter::Zero([]), } } pub fn children_mut(&mut self) -> impl DoubleEndedIterator { multi_iterator!(ChildrenIter { Zero, Vec }); match self { Pattern::Ctr(_, els) | Pattern::Fan(.., els) | Pattern::Lst(els) => ChildrenIter::Vec(els.iter_mut()), Pattern::Var(_) | Pattern::Chn(_) | Pattern::Num(_) | Pattern::Str(_) => ChildrenIter::Zero([]), } } /// Returns an iterator over each subpattern in depth-first, left to right order. // TODO: Not lazy. pub fn iter(&self) -> impl DoubleEndedIterator + Clone { let mut to_visit = vec![self]; let mut els = vec![]; while let Some(pat) = to_visit.pop() { els.push(pat); to_visit.extend(pat.children().rev()); } els.into_iter() } pub fn is_wildcard(&self) -> bool { matches!(self, Pattern::Var(_) | Pattern::Chn(_)) } pub fn to_term(&self) -> Term { match self { Pattern::Var(nam) => Term::var_or_era(nam.clone()), Pattern::Chn(nam) => Term::Link { nam: nam.clone() }, Pattern::Ctr(ctr, args) => { Term::call(Term::Ref { nam: ctr.clone() }, args.iter().map(|arg| arg.to_term())) } Pattern::Num(val) => Term::Num { val: Num::U24(*val) }, Pattern::Fan(fan, tag, args) => { Term::Fan { fan: *fan, tag: tag.clone(), els: args.iter().map(|p| p.to_term()).collect() } } Pattern::Lst(_) | Pattern::Str(_) => todo!(), } } pub fn has_unscoped(&self) -> bool { match self { Pattern::Chn(_) => true, Pattern::Var(_) | Pattern::Str(_) | Pattern::Num(_) => false, Pattern::Ctr(_, x) | Pattern::Fan(_, _, x) | Pattern::Lst(x) => x.iter().any(|x| x.has_unscoped()), } } pub fn has_nested(&self) -> bool { for child in self.children() { if matches!(child, Pattern::Ctr(_, _) | Pattern::Fan(_, _, _) | Pattern::Lst(_)) { return true; } } false } } impl Rule { pub fn arity(&self) -> usize { self.pats.len() } } impl Definition { pub fn new_gen(name: Name, rules: Vec, source: Source, check: bool) -> Self { let kind = if source.is_builtin() { SourceKind::Builtin } else { SourceKind::Generated }; let source = Source { kind, ..source }; Self { name, typ: Type::Hole, check, rules, source } } pub fn is_builtin(&self) -> bool { self.source.is_builtin() } pub fn arity(&self) -> usize { self.rules[0].arity() } #[track_caller] pub fn assert_no_pattern_matching_rules(&self) { assert!(self.rules.len() == 1, "Definition rules should have been removed in earlier pass"); assert!(self.rules[0].pats.is_empty(), "Definition args should have been removed in an earlier pass"); } #[track_caller] pub fn rule(&self) -> &Rule { self.assert_no_pattern_matching_rules(); &self.rules[0] } #[track_caller] pub fn rule_mut(&mut self) -> &mut Rule { self.assert_no_pattern_matching_rules(); &mut self.rules[0] } } impl Type { /// Substitutes the occurrences of a type constructor with the given name. /// Substitutes both `Var` and `Ctr` types since `Var` could be referring to /// an unresolved type constructor. pub fn subst_ctr(&mut self, from: &Name, to: &Name) { maybe_grow(|| { match self { Type::Var(nam) => { if nam == from { *nam = to.clone(); } } Type::Ctr(nam, _) => { if nam == from { *nam = to.clone(); } } _ => (), }; for child in self.children_mut() { child.subst_ctr(from, to); } }) } pub fn children(&self) -> impl Iterator { multi_iterator!(ChildrenIter { Zero, One, Two, Vec }); match self { Type::Any | Type::None | Type::Hole | Type::I24 | Type::F24 | Type::U24 | Type::Var(_) => { ChildrenIter::Zero([]) } Type::Number(t) | Type::Integer(t) => ChildrenIter::One([t.as_ref()]), Type::Arr(lft, rgt) => ChildrenIter::Two([lft.as_ref(), rgt.as_ref()]), Type::Tup(els) | Type::Ctr(_, els) => ChildrenIter::Vec(els), } } pub fn children_mut(&mut self) -> impl Iterator { multi_iterator!(ChildrenIter { Zero, One, Two, Vec }); match self { Type::Any | Type::None | Type::Hole | Type::I24 | Type::F24 | Type::U24 | Type::Var(_) => { ChildrenIter::Zero([]) } Type::Number(t) | Type::Integer(t) => ChildrenIter::One([t.as_mut()]), Type::Arr(lft, rgt) => ChildrenIter::Two([lft.as_mut(), rgt.as_mut()]), Type::Tup(els) | Type::Ctr(_, els) => ChildrenIter::Vec(els), } } } impl Name { pub fn new<'a, V: Into>>(value: V) -> Name { Name(STRINGS.get(value)) } pub fn is_generated(&self) -> bool { // Generated def names use $ while var names use % self.contains("__") || self.contains('%') } pub fn def_name_from_generated(&self) -> Name { if let Some(nam) = self.strip_prefix("__") { Name::new(nam) } else if let Some((nam, _)) = self.split_once("__") { Name::new(nam) } else { self.clone() } } } impl Default for Name { fn default() -> Self { Self::new("") } } impl From for Name { fn from(value: u64) -> Self { Name::new(num_to_name(value).as_str()) } } impl From for Name { fn from(value: u32) -> Self { Name::new(num_to_name(value as u64).as_str()) } } impl Deref for Name { type Target = str; fn deref(&self) -> &Self::Target { &self.0 } } impl AsRef for Name { fn as_ref(&self) -> &str { &self.0 } } impl Book { pub fn hvm_entrypoint(&self) -> &str { match self.entrypoint.as_ref().map(|e| e.as_ref()) { Some("main" | "Main") | None => ENTRY_POINT, Some(nam) => nam, } } } impl Source { pub fn is_builtin(&self) -> bool { matches!(self.kind, SourceKind::Builtin) } pub fn is_local(&self) -> bool { matches!(self.kind, SourceKind::User) } pub fn from_file_span(file: &Name, txt: &str, span: Range, builtin: bool) -> Self { let span = Some(TextSpan::from_byte_span(txt, span)); let kind = if builtin { SourceKind::Builtin } else { SourceKind::User }; let file = Some(file.to_string()); Source { file, span, kind } } } impl Default for Source { fn default() -> Self { Self { file: None, span: None, kind: SourceKind::Unknown } } } #[test] fn num_to_from_bits() { let a = [ Num::U24(0), Num::U24(0xFFFFFF), Num::U24(12345), Num::I24(0), Num::I24(0x7FFFFF), Num::I24(12345), Num::I24(-12345), Num::F24(0.0), Num::I24(-0), Num::F24(0xFFFFFF as f32), Num::F24(0.0), Num::F24(-0.0), Num::F24(0.00123), Num::F24(12345.023), Num::F24(-1235.3849), Num::F24(1.0), Num::F24(-1.0), Num::F24(12323658716.0), Num::F24(-12323658716.0), Num::F24(-0.00000000000000001), Num::F24(0.00000000000000001), Num::F24(5447856134985749851.3457896137815694178), Num::F24(-5447856134985749851.3457896137815694178), ]; for b in a { assert_eq!(b, Num::from_bits(Num::to_bits(&b))); } } ================================================ FILE: src/fun/net_to_term.rs ================================================ use crate::{ diagnostics::{DiagnosticOrigin, Diagnostics, Severity}, fun::{term_to_net::Labels, Book, FanKind, Name, Num, Op, Pattern, Tag, Term}, maybe_grow, net::{BendLab, CtrKind, INet, NodeId, NodeKind, Port, SlotId, ROOT}, }; use hvm::hvm::Numb; use std::collections::{BTreeSet, HashMap, HashSet}; /// Converts an Interaction-INet to a Lambda Calculus term pub fn net_to_term( net: &INet, book: &Book, labels: &Labels, linear: bool, diagnostics: &mut Diagnostics, ) -> Term { let mut reader = Reader { net, labels, book, recursive_defs: &book.recursive_defs(), dup_paths: if linear { None } else { Some(Default::default()) }, scope: Default::default(), seen_fans: Default::default(), namegen: Default::default(), seen: Default::default(), errors: Default::default(), }; let mut term = reader.read_term(net.enter_port(ROOT)); while let Some(node) = reader.scope.pop_first() { let val = reader.read_term(reader.net.enter_port(Port(node, 0))); let fst = reader.namegen.decl_name(net, Port(node, 1)); let snd = reader.namegen.decl_name(net, Port(node, 2)); let (fan, tag) = match reader.net.node(node).kind { NodeKind::Ctr(CtrKind::Tup(lab)) => (FanKind::Tup, reader.labels.tup.to_tag(lab)), NodeKind::Ctr(CtrKind::Dup(lab)) => (FanKind::Dup, reader.labels.dup.to_tag(Some(lab))), _ => unreachable!(), }; let split = &mut Split { fan, tag, fst, snd, val }; let uses = term.insert_split(split, usize::MAX).unwrap(); let result = term.insert_split(split, uses); debug_assert_eq!(result, None); } reader.report_errors(diagnostics); let mut unscoped = HashSet::new(); let mut scope = Vec::new(); term.collect_unscoped(&mut unscoped, &mut scope); term.apply_unscoped(&unscoped); term } // BTreeSet for consistent readback of dups type Scope = BTreeSet; pub struct Reader<'a> { pub book: &'a Book, pub namegen: NameGen, net: &'a INet, labels: &'a Labels, dup_paths: Option>>, /// Store for floating/unscoped terms, like dups and let tups. scope: Scope, // To avoid reinserting things in the scope. seen_fans: Scope, seen: HashSet, errors: Vec, recursive_defs: &'a BTreeSet, } impl Reader<'_> { fn read_term(&mut self, next: Port) -> Term { use CtrKind::*; maybe_grow(|| { if !self.seen.insert(next) && self.dup_paths.is_none() { self.error(ReadbackError::Cyclic); return Term::Var { nam: Name::new("...") }; } let node = next.node_id(); match &self.net.node(node).kind { NodeKind::Era => Term::Era, NodeKind::Ctr(CtrKind::Con(lab)) => self.read_con(next, *lab), NodeKind::Swi => self.read_swi(next), NodeKind::Ref { def_name } => Term::Ref { nam: def_name.clone() }, NodeKind::Ctr(kind @ (Dup(_) | Tup(_))) => self.read_fan(next, *kind), NodeKind::Num { val } => num_from_bits_with_type(*val, *val), NodeKind::Opr => self.read_opr(next), NodeKind::Rot => { self.error(ReadbackError::ReachedRoot); Term::Err } } }) } /// Reads a term from a CON node. /// Could be a lambda, an application, a CON tuple or a CON tuple elimination. fn read_con(&mut self, next: Port, label: Option) -> Term { let node = next.node_id(); match next.slot() { // If we're visiting a port 0, then it is a tuple or a lambda. 0 => { if self.is_tup(node) { // A tuple let lft = self.read_term(self.net.enter_port(Port(node, 1))); let rgt = self.read_term(self.net.enter_port(Port(node, 2))); Term::Fan { fan: FanKind::Tup, tag: self.labels.con.to_tag(label), els: vec![lft, rgt] } } else { // A lambda let nam = self.namegen.decl_name(self.net, Port(node, 1)); let bod = self.read_term(self.net.enter_port(Port(node, 2))); Term::Lam { tag: self.labels.con.to_tag(label), pat: Box::new(Pattern::Var(nam)), bod: Box::new(bod), } } } // If we're visiting a port 1, then it is a variable. 1 => Term::Var { nam: self.namegen.var_name(next) }, // If we're visiting a port 2, then it is an application. 2 => { let fun = self.read_term(self.net.enter_port(Port(node, 0))); let arg = self.read_term(self.net.enter_port(Port(node, 1))); Term::App { tag: self.labels.con.to_tag(label), fun: Box::new(fun), arg: Box::new(arg) } } _ => unreachable!(), } } /// Reads a fan term from a DUP node. /// Could be a superposition, a duplication, a DUP tuple or a DUP tuple elimination. fn read_fan(&mut self, next: Port, kind: CtrKind) -> Term { let node = next.node_id(); let (fan, lab) = match kind { CtrKind::Tup(lab) => (FanKind::Tup, lab), CtrKind::Dup(lab) => (FanKind::Dup, Some(lab)), _ => unreachable!(), }; match next.slot() { // If we're visiting a port 0, then it is a pair. 0 => { // If this superposition is in a readback path with a paired Dup, // we resolve it by splitting the two sup values into the two Dup variables. // If we find that it's not paired with a Dup, we just keep the Sup as a term. // The latter are all the early returns. if fan != FanKind::Dup { return self.decay_or_get_ports(node).unwrap_or_else(|(fst, snd)| Term::Fan { fan, tag: self.labels[fan].to_tag(lab), els: vec![fst, snd], }); } let Some(dup_paths) = &mut self.dup_paths else { return self.decay_or_get_ports(node).unwrap_or_else(|(fst, snd)| Term::Fan { fan, tag: self.labels[fan].to_tag(lab), els: vec![fst, snd], }); }; let stack = dup_paths.entry(lab.unwrap()).or_default(); let Some(slot) = stack.pop() else { return self.decay_or_get_ports(node).unwrap_or_else(|(fst, snd)| Term::Fan { fan, tag: self.labels[fan].to_tag(lab), els: vec![fst, snd], }); }; // Found a paired Dup, so we "decay" the superposition according to the original direction we came from the Dup. let term = self.read_term(self.net.enter_port(Port(node, slot))); self.dup_paths.as_mut().unwrap().get_mut(&lab.unwrap()).unwrap().push(slot); term } // If we're visiting a port 1 or 2, then it is a variable. // Also, that means we found a dup, so we store it to read later. 1 | 2 => { // If doing non-linear readback, we also store dup paths to try to resolve them later. if let Some(dup_paths) = &mut self.dup_paths { if fan == FanKind::Dup { dup_paths.entry(lab.unwrap()).or_default().push(next.slot()); let term = self.read_term(self.net.enter_port(Port(node, 0))); self.dup_paths.as_mut().unwrap().entry(lab.unwrap()).or_default().pop().unwrap(); return term; } } // Otherwise, just store the new dup/let tup and return the variable. if self.seen_fans.insert(node) { self.scope.insert(node); } Term::Var { nam: self.namegen.var_name(next) } } _ => unreachable!(), } } /// Reads an Opr term from an OPR node. fn read_opr(&mut self, next: Port) -> Term { /// Read one of the argument ports of an operation. fn add_arg( reader: &mut Reader, port: Port, args: &mut Vec>, types: &mut Vec, ops: &mut Vec, ) { if let NodeKind::Num { val } = reader.net.node(port.node_id()).kind { match hvm::hvm::Numb::get_typ(&Numb(val)) { // Contains an operation hvm::hvm::TY_SYM => { ops.push(hvm::hvm::Numb(val).get_sym()); } // Contains a number with a type typ @ hvm::hvm::TY_U24..=hvm::hvm::TY_F24 => { types.push(typ); args.push(Ok(val)); } // Contains a partially applied number with operation and no type op @ hvm::hvm::OP_ADD.. => { ops.push(op); args.push(Ok(val)); } } } else { // Some other non-number argument let term = reader.read_term(port); args.push(Err(term)); } } /// Creates an Opr term from the arguments of the subnet of an OPR node. fn opr_term_from_hvm_args( args: &mut Vec>, types: &mut Vec, ops: &mut Vec, is_flipped: bool, ) -> Term { let typ = match types.as_slice() { [typ] => *typ, // Use U24 as default number type [] => hvm::hvm::TY_U24, _ => { // Too many types return Term::Err; } }; match (args.as_slice(), ops.as_slice()) { ([arg1, arg2], [op]) => { // Correct number of arguments let arg1 = match arg1 { Ok(val) => num_from_bits_with_type(*val, typ as u32), Err(val) => val.clone(), }; let arg2 = match arg2 { Ok(val) => num_from_bits_with_type(*val, typ as u32), Err(val) => val.clone(), }; let (arg1, arg2) = if is_flipped ^ op_is_flipped(*op) { (arg2, arg1) } else { (arg1, arg2) }; let Some(op) = op_from_native_tag(*op, typ) else { // Invalid operator return Term::Err; }; Term::Oper { opr: op, fst: Box::new(arg1), snd: Box::new(arg2) } } _ => { // Invalid number of arguments/types/operators Term::Err } } } fn op_is_flipped(op: hvm::hvm::Tag) -> bool { [hvm::hvm::FP_DIV, hvm::hvm::FP_REM, hvm::hvm::FP_SHL, hvm::hvm::FP_SHR, hvm::hvm::FP_SUB].contains(&op) } fn op_from_native_tag(val: hvm::hvm::Tag, typ: hvm::hvm::Tag) -> Option { let op = match val { hvm::hvm::OP_ADD => Op::ADD, hvm::hvm::OP_SUB => Op::SUB, hvm::hvm::FP_SUB => Op::SUB, hvm::hvm::OP_MUL => Op::MUL, hvm::hvm::OP_DIV => Op::DIV, hvm::hvm::FP_DIV => Op::DIV, hvm::hvm::OP_REM => Op::REM, hvm::hvm::FP_REM => Op::REM, hvm::hvm::OP_EQ => Op::EQ, hvm::hvm::OP_NEQ => Op::NEQ, hvm::hvm::OP_LT => Op::LT, hvm::hvm::OP_GT => Op::GT, hvm::hvm::OP_AND => { if typ == hvm::hvm::TY_F24 { todo!("Implement readback of atan2") } else { Op::AND } } hvm::hvm::OP_OR => { if typ == hvm::hvm::TY_F24 { todo!("Implement readback of log") } else { Op::OR } } hvm::hvm::OP_XOR => { if typ == hvm::hvm::TY_F24 { Op::POW } else { Op::XOR } } hvm::hvm::OP_SHL => Op::SHL, hvm::hvm::FP_SHL => Op::SHL, hvm::hvm::OP_SHR => Op::SHR, hvm::hvm::FP_SHR => Op::SHR, _ => return None, }; Some(op) } let node = next.node_id(); match next.slot() { 2 => { // If port1 has a partially applied number, the operation has 1 node. // Port0 has arg1 and port1 has arg2. // The operation is interpreted as being pre-flipped (if its a FP_, they cancel and don't flip). let port1_kind = self.net.node(self.net.enter_port(Port(node, 1)).node_id()).kind.clone(); if let NodeKind::Num { val } = port1_kind { match hvm::hvm::Numb::get_typ(&Numb(val)) { hvm::hvm::OP_ADD.. => { let x1_port = self.net.enter_port(Port(node, 0)); let x2_port = self.net.enter_port(Port(node, 1)); let mut args = vec![]; let mut types = vec![]; let mut ops = vec![]; add_arg(self, x1_port, &mut args, &mut types, &mut ops); add_arg(self, x2_port, &mut args, &mut types, &mut ops); let term = opr_term_from_hvm_args(&mut args, &mut types, &mut ops, true); if let Term::Err = term { // Since that function doesn't have access to the reader, add the error here. self.error(ReadbackError::InvalidNumericOp); } return term; } _ => { // Not a partially applied number, handle it in the next case } } } // If port0 has a partially applied number, it also has 1 node. // The operation is interpreted as not pre-flipped. let port0_kind = self.net.node(self.net.enter_port(Port(node, 0)).node_id()).kind.clone(); if let NodeKind::Num { val } = port0_kind { match hvm::hvm::Numb::get_typ(&Numb(val)) { hvm::hvm::OP_ADD.. => { let x1_port = self.net.enter_port(Port(node, 0)); let x2_port = self.net.enter_port(Port(node, 1)); let mut args = vec![]; let mut types = vec![]; let mut ops = vec![]; add_arg(self, x1_port, &mut args, &mut types, &mut ops); add_arg(self, x2_port, &mut args, &mut types, &mut ops); let term = opr_term_from_hvm_args(&mut args, &mut types, &mut ops, false); if let Term::Err = term { // Since that function doesn't have access to the reader, add the error here. self.error(ReadbackError::InvalidNumericOp); } return term; } _ => { // Not a partially applied number, handle it in the next case } } } // Otherwise, the operation has 2 nodes. // Read the top node port0 and 1, bottom node port1. // Args are in that order, skipping the operation. let bottom_id = node; let top_id = self.net.enter_port(Port(bottom_id, 0)).node_id(); if let NodeKind::Opr = self.net.node(top_id).kind { let x1_port = self.net.enter_port(Port(top_id, 0)); let x2_port = self.net.enter_port(Port(top_id, 1)); let x3_port = self.net.enter_port(Port(bottom_id, 1)); let mut args = vec![]; let mut types = vec![]; let mut ops = vec![]; add_arg(self, x1_port, &mut args, &mut types, &mut ops); add_arg(self, x2_port, &mut args, &mut types, &mut ops); add_arg(self, x3_port, &mut args, &mut types, &mut ops); let term = opr_term_from_hvm_args(&mut args, &mut types, &mut ops, false); if let Term::Err = term { self.error(ReadbackError::InvalidNumericOp); } term } else { // Port 0 was not an OPR node, invalid. self.error(ReadbackError::InvalidNumericOp); Term::Err } } _ => { // Entered from a port other than 2, invalid. self.error(ReadbackError::InvalidNumericOp); Term::Err } } } /// Reads a switch term from a SWI node. fn read_swi(&mut self, next: Port) -> Term { let node = next.node_id(); match next.slot() { 2 => { // Read the matched expression let arg = self.read_term(self.net.enter_port(Port(node, 0))); let bnd = if let Term::Var { nam } = &arg { nam.clone() } else { self.namegen.unique() }; // Read the pattern matching node let sel_node = self.net.enter_port(Port(node, 1)).node_id(); // We expect the pattern matching node to be a CON let sel_kind = &self.net.node(sel_node).kind; if sel_kind != &NodeKind::Ctr(CtrKind::Con(None)) { // TODO: Is there any case where we expect a different node type here on readback? self.error(ReadbackError::InvalidNumericMatch); return Term::Err; } let zero = self.read_term(self.net.enter_port(Port(sel_node, 1))); let mut succ = self.read_term(self.net.enter_port(Port(sel_node, 2))); // Call expand_generated in case of succ_term be a lifted term succ.expand_generated(self.book, self.recursive_defs); // Succ term should be a lambda let succ = match &mut succ { Term::Lam { pat, bod, .. } => { if let Pattern::Var(nam) = pat.as_ref() { let mut bod = std::mem::take(bod.as_mut()); if let Some(nam) = nam { bod.subst(nam, &Term::Var { nam: Name::new(format!("{bnd}-1")) }); } bod } else { // Readback should never generate non-var patterns for lambdas. self.error(ReadbackError::InvalidNumericMatch); succ } } _ => { self.error(ReadbackError::InvalidNumericMatch); succ } }; Term::Swt { arg: Box::new(arg), bnd: Some(bnd), with_arg: vec![], with_bnd: vec![], pred: None, arms: vec![zero, succ], } } _ => { self.error(ReadbackError::InvalidNumericMatch); Term::Err } } } /// Enters both ports 1 and 2 of a node. Returns a Term if it is /// possible to simplify the net, or the Terms on the two ports of the node. /// The two possible outcomes are always equivalent. /// /// If: /// - The node Kind is CON/TUP/DUP /// - Both ports 1 and 2 are connected to the same node on slots 1 and 2 respectively /// - That node Kind is the same as the given node Kind /// /// Then: /// Reads the port 0 of the connected node, and returns that term. /// /// Otherwise: /// Returns the terms on ports 1 and 2 of the given node. /// /// # Example /// /// ```hvm /// // λa let (a, b) = a; (a, b) /// ([a b] [a b]) /// /// // The node `(a, b)` is just a reconstruction of the destructuring of `a`, /// // So we can skip both steps and just return the "value" unchanged: /// /// // λa a /// (a a) /// ``` /// fn decay_or_get_ports(&mut self, node: NodeId) -> Result { let fst_port = self.net.enter_port(Port(node, 1)); let snd_port = self.net.enter_port(Port(node, 2)); let node_kind = &self.net.node(node).kind; // Eta-reduce the readback inet. // This is not valid for all kinds of nodes, only CON/TUP/DUP, due to their interaction rules. if matches!(node_kind, NodeKind::Ctr(_)) { match (fst_port, snd_port) { (Port(fst_node, 1), Port(snd_node, 2)) if fst_node == snd_node => { if self.net.node(fst_node).kind == *node_kind { self.scope.remove(&fst_node); let port_zero = self.net.enter_port(Port(fst_node, 0)); let term = self.read_term(port_zero); return Ok(term); } } _ => {} } } let fst = self.read_term(fst_port); let snd = self.read_term(snd_port); Err((fst, snd)) } pub fn error(&mut self, error: ReadbackError) { self.errors.push(error); } pub fn report_errors(&mut self, diagnostics: &mut Diagnostics) { let mut err_counts = std::collections::HashMap::new(); for err in &self.errors { *err_counts.entry(*err).or_insert(0) += 1; } for (err, count) in err_counts { let count_msg = if count > 1 { format!(" ({count} occurrences)") } else { "".to_string() }; let msg = format!("{}{}", err, count_msg); diagnostics.add_diagnostic( msg.as_str(), Severity::Warning, DiagnosticOrigin::Readback, Default::default(), ); } } /// Returns whether the given port represents a tuple or some other /// term (usually a lambda). /// /// Used heuristic: a con node is a tuple if port 1 is a closed tree and not an ERA. fn is_tup(&self, node: NodeId) -> bool { if !matches!(self.net.node(node).kind, NodeKind::Ctr(CtrKind::Con(_))) { return false; } if self.net.node(self.net.enter_port(Port(node, 1)).node_id()).kind == NodeKind::Era { return false; } let mut wires = HashSet::new(); let mut to_check = vec![self.net.enter_port(Port(node, 1))]; while let Some(port) = to_check.pop() { match port.slot() { 0 => { let node = port.node_id(); let lft = self.net.enter_port(Port(node, 1)); let rgt = self.net.enter_port(Port(node, 2)); to_check.push(lft); to_check.push(rgt); } 1 | 2 => { // Mark as a wire. If already present, mark as visited by removing it. if !(wires.insert(port) && wires.insert(self.net.enter_port(port))) { wires.remove(&port); wires.remove(&self.net.enter_port(port)); } } _ => unreachable!(), } } // No hanging wires = a combinator = a tuple wires.is_empty() } } /* Utils for numbers and numeric operations */ /// From an hvm number carrying the value and another carrying the type, return a Num term. fn num_from_bits_with_type(val: u32, typ: u32) -> Term { match hvm::hvm::Numb::get_typ(&Numb(typ)) { // No type information, assume u24 by default hvm::hvm::TY_SYM => Term::Num { val: Num::U24(Numb::get_u24(&Numb(val))) }, hvm::hvm::TY_U24 => Term::Num { val: Num::U24(Numb::get_u24(&Numb(val))) }, hvm::hvm::TY_I24 => Term::Num { val: Num::I24(Numb::get_i24(&Numb(val))) }, hvm::hvm::TY_F24 => Term::Num { val: Num::F24(Numb::get_f24(&Numb(val))) }, _ => Term::Err, } } /* Insertion of dups in the middle of the term */ /// Represents `let #tag(fst, snd) = val` / `let #tag{fst snd} = val` struct Split { fan: FanKind, tag: Tag, fst: Option, snd: Option, val: Term, } impl Default for Split { fn default() -> Self { Self { fan: FanKind::Dup, tag: Default::default(), fst: Default::default(), snd: Default::default(), val: Default::default(), } } } impl Term { /// Calculates the number of times `fst` and `snd` appear in this term. If /// that is `>= threshold`, it inserts the split at this term, and returns /// `None`. Otherwise, returns `Some(uses)`. /// /// This is only really useful when called in two passes – first, with /// `threshold = usize::MAX`, to count the number of uses, and then with /// `threshold = uses`. /// /// This has the effect of inserting the split at the lowest common ancestor /// of all of the uses of `fst` and `snd`. fn insert_split(&mut self, split: &mut Split, threshold: usize) -> Option { maybe_grow(|| { let mut n = match self { Term::Var { nam } => usize::from(split.fst == *nam || split.snd == *nam), _ => 0, }; for child in self.children_mut() { n += child.insert_split(split, threshold)?; } if n >= threshold { let Split { fan, tag, fst, snd, val } = std::mem::take(split); let nxt = Box::new(std::mem::take(self)); *self = Term::Let { pat: Box::new(Pattern::Fan(fan, tag, vec![Pattern::Var(fst), Pattern::Var(snd)])), val: Box::new(val), nxt, }; None } else { Some(n) } }) } } /* Variable name generation */ #[derive(Default)] pub struct NameGen { pub var_port_to_id: HashMap, pub id_counter: u64, } impl NameGen { // Given a port, returns its name, or assigns one if it wasn't named yet. fn var_name(&mut self, var_port: Port) -> Name { let id = self.var_port_to_id.entry(var_port).or_insert_with(|| { let id = self.id_counter; self.id_counter += 1; id }); Name::from(*id) } fn decl_name(&mut self, net: &INet, var_port: Port) -> Option { // If port is linked to an erase node, return an unused variable let var_use = net.enter_port(var_port); let var_kind = &net.node(var_use.node_id()).kind; (*var_kind != NodeKind::Era).then(|| self.var_name(var_port)) } pub fn unique(&mut self) -> Name { let id = self.id_counter; self.id_counter += 1; Name::from(id) } } /* Readback errors */ #[derive(Debug, Clone, Copy)] pub enum ReadbackError { InvalidNumericMatch, InvalidNumericOp, ReachedRoot, Cyclic, } impl PartialEq for ReadbackError { fn eq(&self, other: &Self) -> bool { core::mem::discriminant(self) == core::mem::discriminant(other) } } impl Eq for ReadbackError {} impl std::hash::Hash for ReadbackError { fn hash(&self, state: &mut H) { core::mem::discriminant(self).hash(state); } } impl std::fmt::Display for ReadbackError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { ReadbackError::InvalidNumericMatch => write!(f, "Encountered an invalid 'switch'."), ReadbackError::InvalidNumericOp => write!(f, "Encountered an invalid numeric operation."), ReadbackError::ReachedRoot => { write!(f, "Unable to interpret the HVM result as a valid Bend term. (Reached Root)") } ReadbackError::Cyclic => { write!(f, "Unable to interpret the HVM result as a valid Bend term. (Cyclic Term)") } } } } /* Recover unscoped vars */ impl Term { pub fn collect_unscoped(&self, unscoped: &mut HashSet, scope: &mut Vec) { maybe_grow(|| match self { Term::Var { nam } if !scope.contains(nam) => _ = unscoped.insert(nam.clone()), Term::Swt { arg, bnd, with_bnd: _, with_arg, pred: _, arms } => { arg.collect_unscoped(unscoped, scope); for arg in with_arg { arg.collect_unscoped(unscoped, scope); } arms[0].collect_unscoped(unscoped, scope); if let Some(bnd) = bnd { scope.push(Name::new(format!("{bnd}-1"))); } arms[1].collect_unscoped(unscoped, scope); if bnd.is_some() { scope.pop(); } } _ => { for (child, binds) in self.children_with_binds() { let binds: Vec<_> = binds.collect(); for bind in binds.iter().copied().flatten() { scope.push(bind.clone()); } child.collect_unscoped(unscoped, scope); for _bind in binds.into_iter().flatten() { scope.pop(); } } } }) } /// Transform the variables that we previously found were unscoped into their unscoped variants. pub fn apply_unscoped(&mut self, unscoped: &HashSet) { maybe_grow(|| { if let Term::Var { nam } = self { if unscoped.contains(nam) { *self = Term::Link { nam: std::mem::take(nam) } } } if let Some(pat) = self.pattern_mut() { pat.apply_unscoped(unscoped); } for child in self.children_mut() { child.apply_unscoped(unscoped); } }) } } impl Pattern { fn apply_unscoped(&mut self, unscoped: &HashSet) { maybe_grow(|| { if let Pattern::Var(Some(nam)) = self { if unscoped.contains(nam) { let nam = std::mem::take(nam); *self = Pattern::Chn(nam); } } for child in self.children_mut() { child.apply_unscoped(unscoped) } }) } } ================================================ FILE: src/fun/parser.rs ================================================ use crate::{ fun::{ display::DisplayFn, Adt, AdtCtr, Adts, Constructors, CtrField, FanKind, HvmDefinition, HvmDefinitions, MatchRule, Name, Num, Op, Pattern, Rule, Source, SourceKind, Tag, Term, Type, STRINGS, }, imp::parser::ImpParser, imports::{Import, ImportCtx, ImportType}, maybe_grow, }; use highlight_error::highlight_error; use indexmap::IndexMap; use itertools::Itertools; use std::ops::Range; use TSPL::{ParseError, Parser}; type FunDefinition = super::Definition; type ImpDefinition = crate::imp::Definition; /// Intermediate representation of a program. #[derive(Debug, Clone, Default)] pub struct ParseBook { /// The `functional` function definitions. pub fun_defs: IndexMap, /// The `imperative` function definitions. pub imp_defs: IndexMap, /// HVM native function definitions. pub hvm_defs: HvmDefinitions, /// The algebraic datatypes defined by the program pub adts: Adts, /// To which type does each constructor belong to. pub ctrs: Constructors, /// Imported packages to be loaded in the program pub import_ctx: ImportCtx, /// File path that the book was loaded from. pub source: Name, } impl ParseBook { pub fn contains_def(&self, name: &Name) -> bool { self.fun_defs.contains_key(name) || self.imp_defs.contains_key(name) || self.hvm_defs.contains_key(name) } pub fn contains_builtin_def(&self, name: &Name) -> Option { self .fun_defs .get(name) .map(|d| d.is_builtin()) .or_else(|| self.imp_defs.get(name).map(|d| d.source.is_builtin())) .or_else(|| self.hvm_defs.get(name).map(|d| d.source.is_builtin())) } } pub type ParseResult = std::result::Result; pub struct FunParser<'i> { file: Name, input: &'i str, index: usize, builtin: bool, } impl<'a> FunParser<'a> { pub fn new(file: Name, input: &'a str, builtin: bool) -> Self { Self { file, input, index: 0, builtin } } /* AST parsing functions */ pub fn parse_book(&mut self, default_book: ParseBook) -> ParseResult { let mut book = default_book; let mut indent = self.advance_newlines()?; while !self.is_eof() { // Record type definition if self.starts_with_keyword("object") { let ini_idx = *self.index(); let mut prs = ImpParser { file: self.file.clone(), input: self.input, index: *self.index(), builtin: self.builtin, }; let (adt, nxt_indent) = prs.parse_object(indent)?; self.index = prs.index; let end_idx = *self.index(); self.add_type_def(adt, &mut book, ini_idx..end_idx)?; indent = nxt_indent; continue; } // Imp function definition if self.starts_with_keyword("def") { let ini_idx = *self.index(); let mut prs = ImpParser { file: self.file.clone(), input: self.input, index: ini_idx, builtin: self.builtin }; let (def, nxt_indent) = prs.parse_function_def(indent)?; self.index = prs.index; let end_idx = *self.index(); self.add_imp_def(def, &mut book, ini_idx..end_idx)?; indent = nxt_indent; continue; } // Fun/Imp type definition if self.starts_with_keyword("type") { fn starts_with_imp_type(p: &mut FunParser) -> ParseResult<()> { p.parse_keyword("type")?; p.skip_trivia_inline()?; p.parse_top_level_name()?; p.skip_trivia_inline()?; if p.starts_with(":") || p.starts_with("(") { Ok(()) } else { Err(ParseError::new((0, 0), "")) } } let ini_idx = *self.index(); let is_imp = starts_with_imp_type(self).is_ok(); self.index = ini_idx; if is_imp { // Imp type definition let mut prs = ImpParser { file: self.file.clone(), input: self.input, index: *self.index(), builtin: self.builtin, }; let (adt, nxt_indent) = prs.parse_type_def(indent)?; self.index = prs.index; let end_idx = *self.index(); self.add_type_def(adt, &mut book, ini_idx..end_idx)?; indent = nxt_indent; continue; } else { // Fun type definition let adt = self.parse_type_def()?; let end_idx = *self.index(); self.add_type_def(adt, &mut book, ini_idx..end_idx)?; indent = self.advance_newlines()?; continue; } } // HVM native function definition if self.starts_with_keyword("hvm") { let ini_idx = self.index; let mut prs = ImpParser { file: self.file.clone(), input: self.input, index: self.index, builtin: self.builtin }; let (def, nxt_indent) = prs.parse_hvm()?; *self.index() = prs.index; let end_idx = *self.index(); self.add_hvm(def, &mut book, ini_idx..end_idx)?; indent = nxt_indent; continue; } // Import declaration if self.starts_with_keyword("from") { let import = self.parse_from_import()?; book.import_ctx.add_import(import); indent = self.advance_newlines()?; continue; } if self.starts_with_keyword("import") { let imports = self.parse_import()?; for imp in imports { book.import_ctx.add_import(imp); } indent = self.advance_newlines()?; continue; } // Fun function definition let ini_idx = *self.index(); let def = self.parse_fun_def()?; let end_idx = *self.index(); self.add_fun_def(def, &mut book, ini_idx..end_idx)?; indent = self.advance_newlines()?; } Ok(book) } fn parse_type_def(&mut self) -> ParseResult { // type (name var1 ... varN) = ctr (| ctr)* let ini_idx = self.index; self.parse_keyword("type")?; self.skip_trivia(); let name; let vars; if self.try_consume("(") { // parens around name and vars self.skip_trivia(); name = self.parse_restricted_name("Datatype")?; vars = self .labelled(|p| p.list_like(|p| p.parse_var_name(), "", ")", "", false, 0), "Type variable or ')'")?; self.consume("=")?; } else { // no parens name = self.parse_restricted_name("Datatype")?; vars = self .labelled(|p| p.list_like(|p| p.parse_var_name(), "", "=", "", false, 0), "Type variable or '='")?; } let mut ctrs = vec![self.parse_type_ctr(&name, &vars)?]; while self.try_consume("|") { ctrs.push(self.parse_type_ctr(&name, &vars)?); } let ctrs = ctrs.into_iter().map(|ctr| (ctr.name.clone(), ctr)).collect::>(); let end_idx = *self.index(); let source = Source::from_file_span(&self.file, self.input, ini_idx..end_idx, self.builtin); let adt = Adt { name, vars, ctrs, source }; Ok(adt) } fn parse_type_ctr(&mut self, type_name: &Name, type_vars: &[Name]) -> ParseResult { // '(' name (( '~'? field) | ('~'? '('field (':' type)? ')') )* ')' // name self.skip_trivia(); let ini_idx = *self.index(); if self.try_consume("(") { // name and optionally fields self.skip_trivia(); let ctr_name = self.parse_top_level_name()?; let ctr_name = Name::new(format!("{type_name}/{ctr_name}")); let fields = self.list_like(|p| p.parse_type_ctr_field(), "", ")", "", false, 0)?; let field_types = fields.iter().map(|f| f.typ.clone()).collect::>(); let end_idx = *self.index(); self.check_repeated_ctr_fields(&fields, &ctr_name, ini_idx..end_idx)?; let typ = make_ctr_type(type_name.clone(), &field_types, type_vars); let ctr = AdtCtr { name: ctr_name, typ, fields }; Ok(ctr) } else { // just name let name = self.parse_restricted_name("Datatype constructor")?; let name = Name::new(format!("{type_name}/{name}")); let typ = make_ctr_type(type_name.clone(), &[], type_vars); let ctr = AdtCtr { name, typ, fields: vec![] }; Ok(ctr) } } fn parse_type_ctr_field(&mut self) -> ParseResult { let rec = self.try_consume("~"); let nam; let typ; if self.try_consume("(") { nam = self.parse_var_name()?; if self.try_consume(":") { typ = self.parse_type_term()?; } else { typ = Type::Any; } self.consume(")")?; } else { nam = self.parse_var_name()?; typ = Type::Any; } Ok(CtrField { nam, typ, rec }) } fn parse_fun_def(&mut self) -> ParseResult { let ini_idx = *self.index(); // Try to parse signature if let Ok((name, args, check, typ)) = self.parse_def_sig() { if self.try_consume("=") { // Single rule with signature let body = self.parse_term()?; let pats = args.into_iter().map(|nam| Pattern::Var(Some(nam))).collect(); let rules = vec![Rule { pats, body }]; let end_idx = *self.index(); let source = Source::from_file_span(&self.file, self.input, ini_idx..end_idx, self.builtin); let def = FunDefinition { name, typ, check, rules, source }; Ok(def) } else { // Multiple rules with signature let mut rules = vec![]; let (_, rule) = self.parse_rule()?; rules.push(rule); while self.starts_with_rule(&name) { let (_, rule) = self.parse_rule()?; rules.push(rule); } let end_idx = *self.index(); let source = Source::from_file_span(&self.file, self.input, ini_idx..end_idx, self.builtin); let def = FunDefinition { name, typ, check, rules, source }; Ok(def) } } else { // Was not a signature, backtrack and read the name from the first rule self.index = ini_idx; // No signature, don't check by default let check = self.parse_checked(false); let mut rules = vec![]; let (name, rule) = self.parse_rule()?; rules.push(rule); while self.starts_with_rule(&name) { let (_, rule) = self.parse_rule()?; rules.push(rule); } let end_idx = *self.index(); let source = Source::from_file_span(&self.file, self.input, ini_idx..end_idx, self.builtin); let def = FunDefinition { name, typ: Type::Any, check, rules, source }; Ok(def) } } /// Parses a function definition signature. /// Returns the name, name of the arguments and the type of the function. fn parse_def_sig(&mut self) -> ParseResult<(Name, Vec, bool, Type)> { // '(' name ((arg | '(' arg (':' type)? ')'))* ')' ':' type // name ((arg | '(' arg (':' type)? ')'))* ':' type // Signature, check by default let check = self.parse_checked(true); let (name, args, typ) = if self.try_consume("(") { let name = self.parse_top_level_name()?; let args = self.list_like(|p| p.parse_def_sig_arg(), "", ")", "", false, 0)?; self.consume(":")?; let typ = self.parse_type_term()?; (name, args, typ) } else { let name = self.parse_top_level_name()?; let args = self.list_like(|p| p.parse_def_sig_arg(), "", ":", "", false, 0)?; let typ = self.parse_type_term()?; (name, args, typ) }; let (args, arg_types): (Vec<_>, Vec<_>) = args.into_iter().unzip(); let typ = make_fn_type(arg_types, typ); Ok((name, args, check, typ)) } fn parse_def_sig_arg(&mut self) -> ParseResult<(Name, Type)> { // name // '(' name ')' // '(' name ':' type ')' if self.try_consume("(") { let name = self.parse_var_name()?; let typ = if self.try_consume(":") { self.parse_type_term()? } else { Type::Any }; self.consume(")")?; Ok((name, typ)) } else { let name = self.parse_var_name()?; Ok((name, Type::Any)) } } fn parse_checked(&mut self, default: bool) -> bool { if self.try_parse_keyword("checked") { true } else if self.try_parse_keyword("unchecked") { false } else { default } } fn parse_from_import(&mut self) -> ParseResult { // from path import package // from path import (a, b) // from path import * self.parse_keyword("from")?; self.skip_trivia_inline()?; let path = self.parse_restricted_name("Path")?; self.skip_trivia_inline()?; self.consume("import")?; self.skip_trivia_inline()?; let relative = path.starts_with("./") | path.starts_with("../"); if self.try_consume("*") { return Ok(Import::new(path, ImportType::Glob, relative)); } if self.try_consume("(") { let sub = self.list_like(|p| p.parse_name_maybe_alias("Name"), "", ")", ",", false, 1)?; return Ok(Import::new(path, ImportType::List(sub), relative)); } let (import, alias) = self.parse_name_maybe_alias("Import")?; Ok(Import::new(path, ImportType::Single(import, alias), relative)) } fn parse_import(&mut self) -> ParseResult> { // import path // import (path/a, path/b) self.parse_keyword("import")?; self.skip_trivia_inline()?; let new_import = |import: Name, alias: Option, relative: bool| -> Import { let (path, import) = match import.rsplit_once('/') { Some((start, end)) => (Name::new(start), Name::new(end)), None => (Name::default(), import), }; Import::new(path, ImportType::Single(import, alias), relative) }; if self.try_consume("(") { let list = self.list_like(|p| p.parse_import_name("Name"), "", ")", ",", false, 1)?; let imports = list.into_iter().map(|(a, b, c)| new_import(a, b, c)).collect_vec(); return Ok(imports); } let (import, alias, relative) = self.parse_import_name("Import")?; let import = new_import(import, alias, relative); Ok(vec![import]) } fn parse_rule_lhs(&mut self) -> ParseResult<(Name, Vec)> { if self.try_consume_exactly("(") { self.skip_trivia(); let name = self.parse_restricted_name("Function")?; let pats = self.list_like(|p| p.parse_pattern(false), "", ")", "", false, 0)?; Ok((name, pats)) } else { // Rule without parens // Here we use a different label for the error because this is // the last alternative case for top-level definitions. let name = self.labelled(|p| p.parse_top_level_name(), "top-level definition")?; let mut pats = vec![]; self.skip_trivia(); while !self.starts_with("=") { pats.push(self.parse_pattern(false)?); self.skip_trivia(); } Ok((name, pats)) } } fn parse_rule(&mut self) -> ParseResult<(Name, Rule)> { self.skip_trivia(); let (name, pats) = self.parse_rule_lhs()?; self.consume("=")?; let body = self.parse_term()?; let rule = Rule { pats, body }; Ok((name, rule)) } fn starts_with_rule(&mut self, expected_name: &Name) -> bool { let ini_idx = *self.index(); self.skip_trivia(); let res = self.parse_rule_lhs(); if !self.try_consume("=") { self.index = ini_idx; return false; } self.index = ini_idx; if let Ok((name, _)) = res { if &name == expected_name { // Found rule with the expected name true } else { // Found rule with a different name false } } else { // Not a rule false } } fn parse_pattern(&mut self, simple: bool) -> ParseResult { maybe_grow(|| { let (tag, unexpected_tag) = self.parse_tag()?; self.skip_trivia(); // Ctr or Tup if self.starts_with("(") { self.advance_one(); let head_ini_idx = *self.index(); let head = self.parse_pattern(simple)?; let head_end_idx = *self.index(); // Tup self.skip_trivia(); if self.starts_with(",") || simple { self.consume(",")?; let mut els = self.list_like(|p| p.parse_pattern(simple), "", ")", ",", true, 1)?; els.insert(0, head); return Ok(Pattern::Fan(FanKind::Tup, tag.unwrap_or(Tag::Static), els)); } // Ctr unexpected_tag(self)?; let Pattern::Var(Some(name)) = head else { return self.expected_spanned("constructor name", head_ini_idx..head_end_idx); }; let els = self.list_like(|p| p.parse_pattern(simple), "", ")", "", false, 0)?; return Ok(Pattern::Ctr(name, els)); } // Dup if self.starts_with("{") { let els = self.list_like(|p| p.parse_pattern(simple), "{", "}", ",", false, 0)?; return Ok(Pattern::Fan(FanKind::Dup, tag.unwrap_or(Tag::Auto), els)); } // List if self.starts_with("[") && !simple { unexpected_tag(self)?; let els = self.list_like(|p| p.parse_pattern(simple), "[", "]", ",", false, 0)?; return Ok(Pattern::Lst(els)); } // String if self.starts_with("\"") && !simple { unexpected_tag(self)?; let str = self.parse_quoted_string()?; return Ok(Pattern::Str(STRINGS.get(str))); } // Char if self.starts_with("'") { unexpected_tag(self)?; let char = self.parse_quoted_char()?; return Ok(Pattern::Num(char as u32)); } // Number if self.peek_one().is_some_and(|c| c.is_ascii_digit()) { unexpected_tag(self)?; let num = self.parse_u32()?; return Ok(Pattern::Num(num)); } // Channel if self.starts_with("$") { unexpected_tag(self)?; self.advance_one(); self.skip_trivia(); let name = self.parse_var_name()?; return Ok(Pattern::Chn(name)); } // Var if self.starts_with("*") || self .peek_one() .is_some_and(|c| c.is_ascii_alphanumeric() || c == '_' || c == '.' || c == '-' || c == '/') { unexpected_tag(self)?; let nam = self.parse_name_or_era()?; return Ok(Pattern::Var(nam)); } let ini_idx = *self.index(); while !(self.is_eof() || self.starts_with("=")) { self.advance_one(); } let cur_idx = *self.index(); self.expected_spanned("pattern or '='", ini_idx..cur_idx) }) } pub fn parse_term(&mut self) -> ParseResult { maybe_grow(|| { let (tag, unexpected_tag) = self.parse_tag()?; self.skip_trivia(); // Lambda, unscoped lambda if self.starts_with("λ") || self.starts_with("@") { self.advance_one(); let tag = tag.unwrap_or(Tag::Static); let pat = self.parse_pattern(true)?; let bod = self.parse_term()?; return Ok(Term::Lam { tag, pat: Box::new(pat), bod: Box::new(bod) }); } // App, Tup, Num Op if self.starts_with("(") { self.advance_one(); self.skip_trivia(); // Opr but maybe something else // ( +/-n , -> Tup with Int/Float // ( +/-n ) -> Int/Float // ( +/-n term -> App with Int/Float // ( * , -> Tup with Era // ( * ) -> Era // ( opr -> Num Op if let Some(opr) = self.try_parse_oper() { if (opr == Op::ADD || opr == Op::SUB) && self.peek_one().is_some_and(|c| "0123456789".contains(c)) { unexpected_tag(self)?; *self.index() -= 1; let num = self.parse_number()?; let head = Term::Num { val: num }; self.skip_trivia(); if self.starts_with(",") { self.consume_exactly(",")?; let tail = self.list_like(|p| p.parse_term(), "", ")", ",", true, 1)?; let els = [head].into_iter().chain(tail).collect(); return Ok(Term::Fan { fan: FanKind::Tup, tag: tag.unwrap_or(Tag::Static), els }); } if self.starts_with(")") { self.consume_exactly(")")?; return Ok(head); } let els = self.list_like(|p| p.parse_term(), "", ")", "", false, 0)?; let term = els.into_iter().fold(head, |fun, arg| Term::App { tag: tag.clone().unwrap_or(Tag::Static), fun: Box::new(fun), arg: Box::new(arg), }); return Ok(term); } self.skip_trivia(); if opr == Op::MUL && self.starts_with(",") { self.consume_exactly(",")?; let tail = self.list_like(|p| p.parse_term(), "", ")", ",", true, 1)?; let els = [Term::Era].into_iter().chain(tail).collect(); return Ok(Term::Fan { fan: FanKind::Tup, tag: tag.unwrap_or(Tag::Static), els }); } if opr == Op::MUL && self.starts_with(")") { self.consume_exactly(")")?; return Ok(Term::Era); } // Opr unexpected_tag(self)?; let fst = self.parse_term()?; let snd = self.parse_term()?; self.consume(")")?; return Ok(Term::Oper { opr, fst: Box::new(fst), snd: Box::new(snd) }); } // Tup or App let head = self.parse_term()?; // Tup self.skip_trivia(); if self.starts_with(",") { let mut els = vec![head]; while self.try_consume(",") { els.push(self.parse_term()?); } self.consume(")")?; return Ok(Term::Fan { fan: FanKind::Tup, tag: tag.unwrap_or(Tag::Static), els }); } // App let els = self.list_like(|p| p.parse_term(), "", ")", "", false, 0)?; let term = els.into_iter().fold(head, |fun, arg| Term::App { tag: tag.clone().unwrap_or(Tag::Static), fun: Box::new(fun), arg: Box::new(arg), }); return Ok(term); } // List if self.starts_with("[") { unexpected_tag(self)?; let els = self.list_like(|p| p.parse_term(), "[", "]", ",", false, 0)?; return Ok(Term::List { els }); } // Tree Node if self.starts_with("![") { self.advance_one(); self.advance_one(); unexpected_tag(self)?; let lft = self.parse_term()?; self.try_consume(","); let rgt = self.parse_term()?; self.labelled(|p| p.consume("]"), "Only two children in a Tree/Node")?; return Ok(Term::call(Term::r#ref("Tree/Node"), [lft, rgt])); } // Tree Leaf if self.starts_with("!") { self.advance_one(); unexpected_tag(self)?; let val = self.parse_term()?; return Ok(Term::app(Term::r#ref("Tree/Leaf"), val)); } // Sup if self.starts_with("{") { let els = self.list_like(|p| p.parse_term(), "{", "}", ",", false, 2)?; return Ok(Term::Fan { fan: FanKind::Dup, tag: tag.unwrap_or(Tag::Auto), els }); } // Unscoped var if self.starts_with("$") { self.advance_one(); unexpected_tag(self)?; self.skip_trivia(); let nam = self.parse_var_name()?; return Ok(Term::Link { nam }); } // Era if self.starts_with("*") { self.advance_one(); unexpected_tag(self)?; return Ok(Term::Era); } // Nat if self.starts_with("#") { self.advance_one(); unexpected_tag(self)?; let val = self.parse_u32()?; return Ok(Term::Nat { val }); } // String if self.starts_with("\"") { unexpected_tag(self)?; let str = self.parse_quoted_string()?; return Ok(Term::Str { val: STRINGS.get(str) }); } // Char if self.starts_with("'") { unexpected_tag(self)?; let char = self.parse_quoted_char()?; return Ok(Term::Num { val: Num::U24(char as u32 & 0x00ff_ffff) }); } // Symbol if self.starts_with("`") { unexpected_tag(self)?; let val = self.parse_quoted_symbol()?; return Ok(Term::Num { val: Num::U24(val) }); } // Native Number if self.peek_one().is_some_and(is_num_char) { unexpected_tag(self)?; let num = self.parse_number()?; return Ok(Term::Num { val: num }); } // Use if self.try_parse_keyword("use") { unexpected_tag(self)?; self.skip_trivia(); let nam = self.parse_var_name()?; self.consume("=")?; let val = self.parse_term()?; self.try_consume(";"); let nxt = self.parse_term()?; return Ok(Term::Use { nam: Some(nam), val: Box::new(val), nxt: Box::new(nxt) }); } // Let if self.try_parse_keyword("let") { unexpected_tag(self)?; let pat = self.parse_pattern(true)?; self.consume("=")?; let val = self.parse_term()?; self.try_consume(";"); let nxt = self.parse_term()?; return Ok(Term::Let { pat: Box::new(pat), val: Box::new(val), nxt: Box::new(nxt) }); } // Ask (monadic operation) if self.try_parse_keyword("ask") { unexpected_tag(self)?; let pat = self.parse_pattern(true)?; self.consume("=")?; let val = self.parse_term()?; self.try_consume(";"); let nxt = self.parse_term()?; return Ok(Term::Ask { pat: Box::new(pat), val: Box::new(val), nxt: Box::new(nxt) }); } // Def if self.try_parse_keyword("def") { self.skip_trivia(); let mut def = self.parse_fun_def()?; def.source.kind = SourceKind::Generated; let nxt = self.parse_term()?; return Ok(Term::Def { def, nxt: Box::new(nxt) }); } // If if self.try_parse_keyword("if") { let mut chain = Vec::new(); let cnd = self.parse_term()?; self.consume("{")?; let thn = self.parse_term()?; self.consume("}")?; chain.push((cnd, thn)); self.skip_trivia_inline()?; while self.try_parse_keyword("elif") { let cnd = self.parse_term()?; self.consume("{")?; let thn = self.parse_term()?; self.consume("}")?; self.skip_trivia_inline()?; chain.push((cnd, thn)); } self.consume("else")?; self.consume("{")?; let els = self.parse_term()?; self.consume("}")?; let els = chain.into_iter().rfold(els, |acc, (cnd, thn)| Term::Swt { bnd: Some(Name::new("%cond")), arg: Box::new(cnd), with_bnd: Vec::new(), with_arg: Vec::new(), pred: Some(Name::new("%cond-1")), arms: vec![acc, thn], }); return Ok(els); } // Match if self.try_parse_keyword("match") { unexpected_tag(self)?; let (bnd, arg) = self.parse_match_arg()?; let (with_bnd, with_arg) = self.parse_with_clause()?; let arms = self.list_like(|p| p.parse_match_arm(), "", "}", ";", false, 1)?; return Ok(Term::Mat { arg: Box::new(arg), bnd, with_bnd, with_arg, arms }); } // Switch if self.try_parse_keyword("switch") { unexpected_tag(self)?; let (bnd, arg) = self.parse_match_arg()?; let (with_bnd, with_arg) = self.parse_with_clause()?; self.try_consume("|"); self.consume("0")?; self.consume(":")?; let zero = self.parse_term()?; self.try_consume(";"); let mut arms = vec![zero]; let mut expected_num = 1; loop { self.try_consume("|"); // case _ if self.try_consume("_") { self.consume(":")?; arms.push(self.parse_term()?); self.try_consume(";"); self.consume("}")?; break; } // case num let val = self.parse_u32()?; if val != expected_num { return self.expected(&format!("'{}'", &expected_num.to_string())); } expected_num += 1; self.consume(":")?; arms.push(self.parse_term()?); self.try_consume(";"); } let pred = Some(Name::new(format!("{}-{}", bnd.as_ref().unwrap(), arms.len() - 1))); return Ok(Term::Swt { arg: Box::new(arg), bnd, with_bnd, with_arg, pred, arms }); } // With (monadic block) if self.try_parse_keyword("with") { unexpected_tag(self)?; let typ = self.parse_name()?; self.consume("{")?; let bod = self.parse_term()?; self.consume("}")?; return Ok(Term::With { typ: Name::new(typ), bod: Box::new(bod) }); } // Fold if self.try_parse_keyword("fold") { unexpected_tag(self)?; let (bnd, arg) = self.parse_match_arg()?; let (with_bnd, with_arg) = self.parse_with_clause()?; let arms = self.list_like(|p| p.parse_match_arm(), "", "}", ";", false, 1)?; return Ok(Term::Fold { arg: Box::new(arg), bnd, with_bnd, with_arg, arms }); } // Bend if self.try_parse_keyword("bend") { unexpected_tag(self)?; let args = self.list_like( |p| { let bind = p.parse_var_name()?; let init = if p.try_consume("=") { p.parse_term()? } else { Term::Var { nam: bind.clone() } }; Ok((bind, init)) }, "", "{", ",", false, 0, )?; let (bind, init): (Vec<_>, Vec<_>) = args.into_iter().unzip(); let bind = bind.into_iter().map(Some).collect::>(); self.skip_trivia(); self.parse_keyword("when")?; let cond = self.parse_term()?; self.consume(":")?; let step = self.parse_term()?; self.skip_trivia(); self.parse_keyword("else")?; self.consume(":")?; let base = self.parse_term()?; self.consume("}")?; return Ok(Term::Bend { bnd: bind, arg: init, cond: Box::new(cond), step: Box::new(step), base: Box::new(base), }); } // Open if self.try_parse_keyword("open") { unexpected_tag(self)?; self.skip_trivia(); let typ = self.parse_top_level_name()?; self.skip_trivia(); let var = self.parse_var_name()?; self.try_consume(";"); let bod = self.parse_term()?; return Ok(Term::Open { typ, var, bod: Box::new(bod) }); } // Var unexpected_tag(self)?; let nam = self.labelled(|p| p.parse_var_name(), "term")?; Ok(Term::Var { nam }) }) } fn parse_name_or_era(&mut self) -> ParseResult> { self.labelled( |p| { if p.try_consume_exactly("*") { Ok(None) } else { let nam = p.parse_var_name()?; Ok(Some(nam)) } }, "name or '*'", ) } /// Parses a tag where it may or may not be valid. /// /// If it is not valid, the returned callback can be used to issue an error. fn parse_tag(&mut self) -> ParseResult<(Option, impl FnOnce(&mut Self) -> ParseResult<()>)> { let index = self.index; self.skip_trivia(); let tag = if self.peek_one() == Some('#') && !self.peek_many(2).is_some_and(|x| x.chars().nth(1).unwrap().is_ascii_digit()) { let msg = "Tagged terms not supported for hvm32.".to_string(); return self.err_msg_spanned(&msg, index..index + 1); } else { None }; let end_index = self.index; Ok((tag.clone(), move |slf: &mut Self| { if let Some(tag) = tag { let msg = format!("Unexpected tag '{tag}'"); slf.err_msg_spanned(&msg, index..end_index) } else { Ok(()) } })) } // A named arg with optional name. fn parse_match_arg(&mut self) -> ParseResult<(Option, Term)> { let ini_idx = *self.index(); let mut arg = self.parse_term()?; let end_idx = *self.index(); self.skip_trivia(); match (&mut arg, self.starts_with("=")) { (Term::Var { nam }, true) => { self.consume("=")?; Ok((Some(std::mem::take(nam)), self.parse_term()?)) } (Term::Var { nam }, false) => Ok((Some(nam.clone()), Term::Var { nam: std::mem::take(nam) })), (_, true) => self.expected_spanned("argument name", ini_idx..end_idx), (arg, false) => Ok((Some(Name::new("%arg")), std::mem::take(arg))), } } /// A named arg with non-optional name. fn parse_named_arg(&mut self) -> ParseResult<(Option, Term)> { let nam = self.parse_var_name()?; self.skip_trivia(); if self.starts_with("=") { self.advance_one(); let arg = self.parse_term()?; Ok((Some(nam), arg)) } else { let arg = Term::Var { nam: nam.clone() }; Ok((Some(nam), arg)) } } fn parse_with_clause(&mut self) -> ParseResult<(Vec>, Vec)> { self.skip_trivia(); let res = if self.try_parse_keyword("with") { self.list_like(|p| p.parse_named_arg(), "", "{", ",", false, 1)?.into_iter().unzip() } else { self.consume_exactly("{")?; (vec![], vec![]) }; Ok(res) } fn parse_match_arm(&mut self) -> ParseResult { self.try_consume("|"); self.skip_trivia(); let nam = self.parse_name_or_era()?; self.consume(":")?; let bod = self.parse_term()?; Ok((nam, vec![], bod)) } fn parse_type_term(&mut self) -> ParseResult { let mut left = self.parse_type_atom()?; self.skip_trivia(); while self.try_consume_exactly("->") { let right = self.parse_type_term()?; left = Type::Arr(Box::new(left), Box::new(right)); } Ok(left) } /// Parses a type without an ending arrow. /// Either an atom, a tuple, a ctr or a parenthesized type. fn parse_type_atom(&mut self) -> ParseResult { self.skip_trivia(); if self.try_parse_keyword("Any") { Ok(Type::Any) } else if self.try_parse_keyword("None") { Ok(Type::None) } else if self.try_parse_keyword("_") { Ok(Type::Hole) } else if self.try_parse_keyword("u24") { Ok(Type::U24) } else if self.try_parse_keyword("i24") { Ok(Type::I24) } else if self.try_parse_keyword("f24") { Ok(Type::F24) } else if self.try_consume_exactly("(") { // Tuple, constructor or parenthesized expression let ini_idx = *self.index(); let head = self.parse_type_term()?; self.skip_trivia(); if self.try_consume_exactly(")") { // Parens Ok(head) } else if self.try_consume_exactly(",") { // Tuple let mut types = vec![head]; loop { types.push(self.parse_type_term()?); self.skip_trivia(); if !self.try_consume_exactly(",") { break; } } self.consume(")")?; Ok(Type::Tup(types)) } else { // Constructor let Type::Var(nam) = head else { let end_idx = *self.index(); // TODO: This is not a good error message return self.expected_spanned("type constructor", ini_idx..end_idx); }; let mut args = vec![]; // We know there's at least one argument, otherwise it would go in the parens case. while !self.try_consume(")") { args.push(self.parse_type_term()?); self.skip_trivia(); } Ok(Type::Ctr(nam, args)) } } else { // Variable // TODO: This will show "expected Name" instead of "expected type" let nam = self.parse_var_name()?; Ok(Type::Var(nam)) } } fn add_fun_def(&mut self, def: FunDefinition, book: &mut ParseBook, span: Range) -> ParseResult<()> { self.check_top_level_redefinition(&def.name, book, span)?; book.fun_defs.insert(def.name.clone(), def); Ok(()) } fn add_imp_def( &mut self, def: crate::imp::Definition, book: &mut ParseBook, span: Range, ) -> ParseResult<()> { self.check_top_level_redefinition(&def.name, book, span)?; book.imp_defs.insert(def.name.clone(), def); Ok(()) } fn add_hvm(&mut self, def: HvmDefinition, book: &mut ParseBook, span: Range) -> ParseResult<()> { self.check_top_level_redefinition(&def.name, book, span)?; book.hvm_defs.insert(def.name.clone(), def); Ok(()) } fn add_type_def(&mut self, adt: Adt, book: &mut ParseBook, span: Range) -> ParseResult<()> { self.check_type_redefinition(&adt.name, book, span.clone())?; for ctr in adt.ctrs.keys() { if let Some(builtin) = book.contains_builtin_def(ctr) { let msg = FunParser::redefinition_of_function_msg(builtin, ctr); return self.err_msg_spanned(&msg, span); } match book.ctrs.entry(ctr.clone()) { indexmap::map::Entry::Vacant(e) => _ = e.insert(adt.name.clone()), indexmap::map::Entry::Occupied(e) => { let msg = FunParser::redefinition_of_constructor_msg(e.key()); return self.err_msg_spanned(&msg, span); } } } book.adts.insert(adt.name.clone(), adt); Ok(()) } fn check_top_level_redefinition( &mut self, name: &Name, book: &mut ParseBook, span: Range, ) -> ParseResult<()> { if let Some(builtin) = book.contains_builtin_def(name) { let msg = Self::redefinition_of_function_msg(builtin, name); return self.err_msg_spanned(&msg, span); } if book.ctrs.contains_key(name) { let msg = Self::redefinition_of_constructor_msg(name); return self.err_msg_spanned(&msg, span); } if book.hvm_defs.contains_key(name) { let msg = Self::redefinition_of_hvm_msg(false, name); return self.err_msg_spanned(&msg, span); } Ok(()) } fn check_type_redefinition( &mut self, name: &Name, book: &mut ParseBook, span: Range, ) -> ParseResult<()> { if book.adts.contains_key(name) { let msg = Self::redefinition_of_type_msg(name); return self.err_msg_spanned(&msg, span); } Ok(()) } } impl<'a> Parser<'a> for FunParser<'a> { fn input(&mut self) -> &'a str { self.input } fn index(&mut self) -> &mut usize { &mut self.index } /// Generates an error message for parsing failures, including the highlighted context. /// /// Override to have our own error message. fn expected(&mut self, exp: &str) -> ParseResult { let ini_idx = *self.index(); let end_idx = *self.index() + 1; self.expected_spanned(exp, ini_idx..end_idx) } /// Generates an error message with an additional custom message. /// /// Override to have our own error message. fn expected_and(&mut self, exp: &str, msg: &str) -> ParseResult { let ini_idx = *self.index(); let end_idx = *self.index() + 1; self.expected_spanned_and(exp, msg, ini_idx..end_idx) } /// Consumes an instance of the given string, erroring if it is not found. /// /// Override to have our own error message. fn consume(&mut self, text: &str) -> ParseResult<()> { self.skip_trivia(); if self.input().get(*self.index()..).unwrap_or_default().starts_with(text) { *self.index() += text.len(); Ok(()) } else { self.expected(format!("'{text}'").as_str()) } } fn skip_trivia(&mut self) { while let Some(c) = self.peek_one() { if c.is_ascii_whitespace() { self.advance_one(); continue; } if c == '#' { self.advance_one(); if let Some(c) = self.peek_one() { if c == '{' { self.advance_one(); while let Some(c) = self.peek_one() { self.advance_one(); if c == '#' { if let Some('}') = self.peek_one() { self.advance_one(); break; } else { self.advance_one(); } } } } else { while let Some(c) = self.peek_one() { if c != '\n' { self.advance_one(); } else { break; } } } } continue; } break; } } } pub fn is_name_char(c: char) -> bool { c.is_ascii_alphanumeric() || c == '_' || c == '.' || c == '-' || c == '/' } pub fn is_num_char(c: char) -> bool { "0123456789+-".contains(c) } pub fn make_fn_type(args: Vec, ret: Type) -> Type { args.into_iter().rfold(ret, |acc, typ| Type::Arr(Box::new(typ), Box::new(acc))) } pub fn make_ctr_type(type_name: Name, fields: &[Type], vars: &[Name]) -> Type { let typ = Type::Ctr(type_name, vars.iter().cloned().map(Type::Var).collect()); let typ = fields.iter().rfold(typ, |acc, typ| Type::Arr(Box::new(typ.clone()), Box::new(acc))); typ } #[derive(Debug, PartialEq, Eq, Clone, Copy)] pub enum Indent { Val(isize), Eof, } impl Indent { pub fn new(val: isize) -> Self { Indent::Val(val) } pub fn enter_level(&mut self) { if let Indent::Val(val) = self { *val += 2; } } pub fn exit_level(&mut self) { if let Indent::Val(val) = self { *val -= 2; } } } impl<'a> ParserCommons<'a> for FunParser<'a> {} pub trait ParserCommons<'a>: Parser<'a> { fn labelled(&mut self, parser: impl Fn(&mut Self) -> ParseResult, label: &str) -> ParseResult { match parser(self) { Ok(val) => Ok(val), Err(_) => self.expected(label), } } fn parse_restricted_name(&mut self, kind: &str) -> ParseResult { let ini_idx = *self.index(); let name = self.take_while(is_name_char); if name.is_empty() { self.expected(&format!("{kind} name"))? } let name = Name::new(name.to_owned()); let end_idx = *self.index(); if name.contains("__") { let msg = format!("{kind} names are not allowed to contain \"__\"."); self.err_msg_spanned(&msg, ini_idx..end_idx) } else if name.starts_with("//") { let msg = format!("{kind} names are not allowed to start with \"//\"."); self.err_msg_spanned(&msg, ini_idx..end_idx) } else { Ok(name) } } fn parse_top_level_name(&mut self) -> ParseResult { self.parse_restricted_name("Top-level") } fn parse_var_name(&mut self) -> ParseResult { self.parse_restricted_name("Variable") } fn parse_name_maybe_alias(&mut self, label: &str) -> ParseResult<(Name, Option)> { let name = self.parse_restricted_name(label)?; if self.try_consume("as") { self.skip_trivia(); let alias = self.parse_restricted_name("Alias")?; Ok((name, Some(alias))) } else { Ok((name, None)) } } fn parse_import_name(&mut self, label: &str) -> ParseResult<(Name, Option, bool)> { let (import, alias) = self.parse_name_maybe_alias(label)?; let relative = import.starts_with("./") | import.starts_with("../"); Ok((import, alias, relative)) } /// Consumes exactly the text without skipping. fn consume_exactly(&mut self, text: &str) -> ParseResult<()> { if self.input().get(*self.index()..).unwrap_or_default().starts_with(text) { *self.index() += text.len(); Ok(()) } else { self.expected(format!("'{text}'").as_str()) } } fn consume_new_line(&mut self) -> ParseResult<()> { self.skip_trivia_inline()?; self.try_consume_exactly("\r"); self.labelled(|p| p.consume_exactly("\n"), "newline") } /// Skips trivia, returns the number of trivia characters skipped in the last line. fn advance_newlines(&mut self) -> ParseResult { loop { let num_spaces = self.advance_trivia_inline()?; if self.peek_one() == Some('\r') { self.advance_one(); } if self.peek_one() == Some('\n') { self.advance_one(); } else if self.is_eof() { return Ok(Indent::Eof); } else { return Ok(Indent::Val(num_spaces)); } } } /// Advances the parser to the next non-trivia character in the same line. /// Returns how many characters were advanced. fn advance_trivia_inline(&mut self) -> ParseResult { let mut char_count = 0; while let Some(c) = self.peek_one() { if c == '\t' { let idx = *self.index(); return self.err_msg_spanned("Tabs are not accepted for indentation.", idx..idx + 1); } if " ".contains(c) { self.advance_one(); char_count += 1; continue; } if c == '#' { self.advance_one(); char_count += 1; if let Some(c) = self.peek_one() { if c == '{' { self.advance_one(); char_count += 1; while let Some(c) = self.peek_one() { self.advance_one(); char_count += 1; if c == '#' { if let Some('}') = self.peek_one() { self.advance_one(); char_count += 1; break; } else { self.advance_one(); char_count += 1; } } } } else { while let Some(c) = self.peek_one() { if c != '\n' { self.advance_one(); char_count += 1; } else { break; } } } } continue; } break; } Ok(char_count) } /// Skips until the next non-trivia character in the same line. fn skip_trivia_inline(&mut self) -> ParseResult<()> { self.advance_trivia_inline()?; Ok(()) } fn expected_spanned(&mut self, exp: &str, span: Range) -> ParseResult { let is_eof = self.is_eof(); let detected = DisplayFn(|f| if is_eof { write!(f, " end of input") } else { Ok(()) }); let msg = format!("\x1b[1m- expected:\x1b[0m {}\n\x1b[1m- detected:\x1b[0m{}", exp, detected); self.with_ctx(Err(msg), span) } /// Same as `expected_spanned` but adds an information message before the expected message. fn expected_spanned_and(&mut self, exp: &str, msg: &str, span: Range) -> ParseResult { let is_eof = self.is_eof(); let detected = DisplayFn(|f| if is_eof { write!(f, " end of input") } else { Ok(()) }); let msg = format!( "\x1b[1m- information:\x1b[0m {}\n\x1b[1m- expected:\x1b[0m {}\n\x1b[1m- detected:\x1b[0m{}", msg, exp, detected, ); self.with_ctx(Err(msg), span) } /// If the parser result is an error, adds code location information to the error message. fn err_msg_spanned(&mut self, msg: &str, span: Range) -> ParseResult { let is_eof = self.is_eof(); let eof_msg = if is_eof { " end of input" } else { "" }; let msg = format!("{msg}\nLocation:{eof_msg}"); self.with_ctx(Err(msg), span) } /// If the parser result is an error, adds highlighted code context to the message. fn with_ctx(&mut self, res: Result, span: Range) -> ParseResult { res.map_err(|msg| { let ctx = highlight_error(span.start, span.end, self.input()); let msg = format!("{msg}\n{ctx}"); ParseError::new((span.start, span.end), msg) }) } /// Consumes text if the input starts with it or trivia. Otherwise, do nothing. fn try_consume(&mut self, text: &str) -> bool { self.skip_trivia(); if self.starts_with(text) { self.consume(text).unwrap(); true } else { false } } /// Consumes text if the input starts exactly with it. Otherwise, do nothing. fn try_consume_exactly(&mut self, text: &str) -> bool { if self.starts_with(text) { self.consume_exactly(text).unwrap(); true } else { false } } fn try_parse_keyword(&mut self, keyword: &str) -> bool { if self.starts_with_keyword(keyword) { self.consume_exactly(keyword).unwrap(); true } else { false } } fn parse_keyword(&mut self, keyword: &str) -> ParseResult<()> { let ini_idx = *self.index(); self.consume_exactly(keyword)?; let end_idx = *self.index(); let input = &self.input()[*self.index()..]; let next_is_name = input.chars().next().is_some_and(is_name_char); if !next_is_name { Ok(()) } else { self.expected_spanned(&format!("keyword '{keyword}'"), ini_idx..end_idx + 1) } } fn starts_with_keyword(&mut self, keyword: &str) -> bool { if self.starts_with(keyword) { let input = &self.input()[*self.index() + keyword.len()..]; let next_is_name = input.chars().next().is_some_and(is_name_char); !next_is_name } else { false } } /// Parses a list-like structure like "[x1, x2, x3,]". /// Since a list is always well terminated, we consume newlines. /// /// `parser` is a function that parses an element of the list. /// /// If `hard_sep` the separator between elements is mandatory. /// Always accepts trailing separators. /// /// `min_els` determines how many elements must be parsed at minimum. fn list_like( &mut self, mut parser: impl FnMut(&mut Self) -> ParseResult, start: &str, end: &str, sep: &str, hard_sep: bool, min_els: usize, ) -> ParseResult> { self.consume_exactly(start)?; let mut els = vec![]; // Consume the minimum number of elements for i in 0..min_els { self.skip_trivia(); els.push(parser(self)?); self.skip_trivia(); if hard_sep && !(i == min_els - 1 && self.starts_with(end)) { self.consume(sep)?; } else { self.try_consume(sep); } } // Consume optional elements while !self.try_consume(end) { els.push(parser(self)?); self.skip_trivia(); if hard_sep && !self.starts_with(end) { self.consume(sep)?; } else { self.try_consume(sep); } } Ok(els) } fn try_parse_oper(&mut self) -> Option { let opr = if self.try_consume_exactly("+") { Op::ADD } else if self.try_consume_exactly("-") { Op::SUB } else if self.try_consume_exactly("**") { Op::POW } else if self.try_consume_exactly("*") { Op::MUL } else if self.try_consume_exactly("/") { Op::DIV } else if self.try_consume_exactly("%") { Op::REM } else if self.try_consume_exactly("<<") { Op::SHL } else if self.try_consume_exactly(">>") { Op::SHR } else if self.try_consume_exactly("<=") { Op::LE } else if self.try_consume_exactly(">=") { Op::GE } else if self.try_consume_exactly("<") { Op::LT } else if self.try_consume_exactly(">") { Op::GT } else if self.try_consume_exactly("==") { Op::EQ } else if self.try_consume_exactly("!=") { Op::NEQ } else if self.try_consume_exactly("&") { Op::AND } else if self.try_consume_exactly("|") { Op::OR } else if self.try_consume_exactly("^") { Op::XOR } else { return None; }; Some(opr) } fn peek_oper(&mut self) -> Option { let opr = if self.starts_with("+") { Op::ADD } else if self.starts_with("-") { Op::SUB } else if self.starts_with("**") { Op::POW } else if self.starts_with("*") { Op::MUL } else if self.starts_with("/") { Op::DIV } else if self.starts_with("%") { Op::REM } else if self.starts_with("<<") { Op::SHL } else if self.starts_with(">>") { Op::SHR } else if self.starts_with("<=") { Op::LE } else if self.starts_with(">=") { Op::GE } else if self.starts_with("<") { Op::LT } else if self.starts_with(">") { Op::GT } else if self.starts_with("==") { Op::EQ } else if self.starts_with("!=") { Op::NEQ } else if self.starts_with("&") { Op::AND } else if self.starts_with("|") { Op::OR } else if self.starts_with("^") { Op::XOR } else { return None; }; Some(opr) } fn parse_u32(&mut self) -> ParseResult { let radix = match self.peek_many(2) { Some("0x") => { self.advance_many(2); Radix::Hex } Some("0b") => { self.advance_many(2); Radix::Bin } _ => Radix::Dec, }; let num_str = self.take_while(move |c| c.is_digit(radix as u32) || c == '_'); let num_str = num_str.chars().filter(|c| *c != '_').collect::(); let next_is_hex = self.peek_one().is_some_and(|c| "0123456789abcdefABCDEF".contains(c)); if next_is_hex || num_str.is_empty() { self.expected(format!("valid {radix} digit").as_str()) } else { u32::from_str_radix(&num_str, radix as u32) .map_err(|e| self.expected_and::("integer", &e.to_string()).unwrap_err()) } } fn u32_with_radix(&mut self, radix: Radix) -> ParseResult { let num_str = self.take_while(move |c| c.is_digit(radix as u32) || c == '_'); let num_str = num_str.chars().filter(|c| *c != '_').collect::(); let next_is_hex = self.peek_one().is_some_and(|c| "0123456789abcdefABCDEF".contains(c)); if next_is_hex || num_str.is_empty() { self.expected(format!("valid {radix} digit").as_str()) } else { u32::from_str_radix(&num_str, radix as u32) .map_err(|e| self.expected_and::("integer", &e.to_string()).unwrap_err()) } } fn parse_number(&mut self) -> ParseResult { let ini_idx = *self.index(); let sign = if self.try_consume_exactly("+") { Some(1) } else if self.try_consume_exactly("-") { Some(-1) } else { None }; let radix = match self.peek_many(2) { Some("0x") => { self.advance_many(2); Radix::Hex } Some("0b") => { self.advance_many(2); Radix::Bin } _ => Radix::Dec, }; let num = self.u32_with_radix(radix)?; let frac = if let Some('.') = self.peek_one() { self.advance_one(); let fra_str = self.take_while(|c| c.is_digit(radix as u32) || c == '_'); let fra_str = fra_str.chars().filter(|c| *c != '_').collect::(); let fra = u32::from_str_radix(&fra_str, radix as u32) .map_err(|e| self.expected_and::("integer", &e.to_string()).unwrap_err())?; let fra = fra as f32 / (radix.to_f32()).powi(fra_str.len() as i32); Some(fra) } else { None }; if let Some(frac) = frac { let sign = sign.unwrap_or(1); return Ok(Num::F24(sign as f32 * (num as f32 + frac))); } if let Some(sign) = sign { let num = sign * num as i32; if !(-0x00800000..=0x007fffff).contains(&num) { return self.num_range_err(ini_idx, "I24"); } Ok(Num::I24(num)) } else { if num >= 1 << 24 { return self.num_range_err(ini_idx, "U24"); } Ok(Num::U24(num)) } } fn num_range_err(&mut self, ini_idx: usize, typ: &str) -> ParseResult { let msg = format!("\x1b[1mNumber literal outside of range for {}.\x1b[0m", typ); let end_idx = *self.index(); self.err_msg_spanned(&msg, ini_idx..end_idx) } /// Parses up to 4 base64 characters surrounded by "`". /// Joins the characters into a u24 and returns it. fn parse_quoted_symbol(&mut self) -> ParseResult { self.consume_exactly("`")?; let mut result = 0; let mut count = 0; while count < 4 { if self.starts_with("`") { break; } count += 1; let Some(c) = self.advance_one() else { self.expected("base_64 character")? }; let c = c as u8; let nxt = match c { b'A'..=b'Z' => c - b'A', b'a'..=b'z' => c - b'a' + 26, b'0'..=b'9' => c - b'0' + 52, b'+' => 62, b'/' => 63, _ => return self.expected("base64 character"), }; result = (result << 6) | nxt as u32; } self.consume_exactly("`")?; Ok(result) } fn check_repeated_ctr_fields( &mut self, fields: &[CtrField], ctr_name: &Name, span: Range, ) -> ParseResult<()> { for i in 0..fields.len() { let field = &fields[i]; if fields.iter().skip(i + 1).any(|a: &CtrField| a.nam == field.nam) { let msg = format!("Found a repeated field '{}' in constructor {}.", field.nam, ctr_name); return self.err_msg_spanned(&msg, span); } } Ok(()) } fn redefinition_of_function_msg(builtin: bool, function_name: &str) -> String { if builtin { format!("Redefinition of builtin (function) '{function_name}'.") } else { format!("Redefinition of function '{function_name}'.") } } fn redefinition_of_hvm_msg(builtin: bool, function_name: &str) -> String { if builtin { format!("Redefinition of builtin (native HVM function) '{function_name}'.") } else { format!("Redefinition of native HVM function '{function_name}'.") } } fn redefinition_of_constructor_msg(constructor_name: &str) -> String { if crate::fun::builtins::BUILTIN_CTRS.contains(&constructor_name) { format!("Redefinition of builtin (constructor) '{constructor_name}'.") } else { format!("Redefinition of constructor '{constructor_name}'.") } } fn redefinition_of_type_msg(type_name: &str) -> String { if crate::fun::builtins::BUILTIN_TYPES.contains(&type_name) { format!("Redefinition of builtin (type) '{type_name}'.") } else { format!("Redefinition of type '{type_name}'.") } } } #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum Radix { Bin = 2, Dec = 10, Hex = 16, } impl Radix { fn to_f32(self) -> f32 { match self { Radix::Bin => 2., Radix::Dec => 10., Radix::Hex => 16., } } } impl std::fmt::Display for Radix { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Radix::Bin => write!(f, "binary"), Radix::Dec => write!(f, "decimal"), Radix::Hex => write!(f, "hexadecimal"), } } } ================================================ FILE: src/fun/term_to_net.rs ================================================ use crate::{ diagnostics::Diagnostics, fun::{num_to_name, Book, FanKind, Name, Op, Pattern, Term}, hvm::{net_trees, tree_children}, maybe_grow, net::CtrKind::{self, *}, }; use hvm::ast::{Net, Tree}; use loaned::LoanedMut; use std::{ collections::{hash_map::Entry, HashMap}, ops::{Index, IndexMut}, }; #[derive(Debug, Clone)] pub struct ViciousCycleErr; pub fn book_to_hvm(book: &Book, diags: &mut Diagnostics) -> Result<(hvm::ast::Book, Labels), Diagnostics> { let mut hvm_book = hvm::ast::Book { defs: Default::default() }; let mut labels = Labels::default(); let main = book.entrypoint.as_ref(); for def in book.defs.values() { for rule in def.rules.iter() { let net = term_to_hvm(&rule.body, &mut labels); let name = if main.is_some_and(|m| &def.name == m) { book.hvm_entrypoint().to_string() } else { def.name.0.to_string() }; match net { Ok(net) => { hvm_book.defs.insert(name, net); } Err(err) => diags.add_inet_error(err, name), } } } // TODO: native hvm nets ignore labels for def in book.hvm_defs.values() { hvm_book.defs.insert(def.name.to_string(), def.body.clone()); } labels.con.finish(); labels.dup.finish(); diags.fatal((hvm_book, labels)) } /// Converts an LC term into an IC net. pub fn term_to_hvm(term: &Term, labels: &mut Labels) -> Result { let mut net = Net { root: Tree::Era, rbag: Default::default() }; let mut state = EncodeTermState { lets: Default::default(), vars: Default::default(), wires: Default::default(), redexes: Default::default(), name_idx: 0, created_nodes: 0, labels, }; state.encode_term(term, Place::Hole(&mut net.root)); LoanedMut::from(std::mem::take(&mut state.redexes)).place(&mut net.rbag); let EncodeTermState { created_nodes, .. } = { state }; let found_nodes = net_trees(&net).map(count_nodes).sum::(); if created_nodes != found_nodes { return Err("Found term that compiles into an inet with a vicious cycle".into()); } Ok(net) } #[derive(Debug)] struct EncodeTermState<'t, 'l> { lets: Vec<(&'t Pattern, &'t Term)>, vars: HashMap<(bool, Name), Place<'t>>, wires: Vec>>, redexes: Vec>, name_idx: u64, created_nodes: usize, labels: &'l mut Labels, } fn count_nodes(tree: &Tree) -> usize { maybe_grow(|| { usize::from(tree_children(tree).next().is_some()) + tree_children(tree).map(count_nodes).sum::() }) } #[derive(Debug)] enum Place<'t> { Tree(LoanedMut<'t, Tree>), Hole(&'t mut Tree), Wire(usize), } impl<'t> EncodeTermState<'t, '_> { /// Adds a subterm connected to `up` to the `inet`. /// `scope` has the current variable scope. /// `vars` has the information of which ports the variables are declared and used in. /// `global_vars` has the same information for global lambdas. Must be linked outside this function. /// Expects variables to be linear, refs to be stored as Refs and all names to be bound. fn encode_term(&mut self, term: &'t Term, up: Place<'t>) { maybe_grow(|| { match term { Term::Era => self.link(up, Place::Tree(LoanedMut::new(Tree::Era))), Term::Var { nam } => self.link_var(false, nam, up), Term::Link { nam } => self.link_var(true, nam, up), Term::Ref { nam } => self.link(up, Place::Tree(LoanedMut::new(Tree::Ref { nam: nam.to_string() }))), Term::Num { val } => { let val = hvm::ast::Numb(val.to_bits()); self.link(up, Place::Tree(LoanedMut::new(Tree::Num { val }))) } // A lambda becomes to a con node. Ports: // - 0: points to where the lambda occurs. // - 1: points to the lambda variable. // - 2: points to the lambda body. // core: (var_use bod) Term::Lam { tag, pat, bod } => { let kind = Con(self.labels.con.generate(tag)); let node = self.new_ctr(kind); self.link(up, node.0); self.encode_pat(pat, node.1); self.encode_term(bod, node.2); } // An application becomes to a con node too. Ports: // - 0: points to the function being applied. // - 1: points to the function's argument. // - 2: points to where the application occurs. // core: & fun ~ (arg ret) (fun not necessarily main port) Term::App { tag, fun, arg } => { let kind = Con(self.labels.con.generate(tag)); let node = self.new_ctr(kind); self.encode_term(fun, node.0); self.encode_term(arg, node.1); self.link(up, node.2); } // core: & arg ~ ?<(zero succ) ret> Term::Swt { arg, bnd, with_bnd, with_arg, pred, arms, } => { // At this point should be only num matches of 0 and succ. assert!(bnd.is_none()); assert!(with_bnd.is_empty()); assert!(with_arg.is_empty()); assert!(pred.is_none()); assert!(arms.len() == 2); self.created_nodes += 2; let loaned = Tree::Swi { fst: Box::new(Tree::Con{fst: Box::new(Tree::Era), snd: Box::new(Tree::Era)}), snd: Box::new(Tree::Era)}; let ((zero, succ, out), node) = LoanedMut::loan_with(loaned, |t, l| { let Tree::Swi { fst, snd: out } = t else { unreachable!() }; let Tree::Con { fst:zero, snd: succ } = fst.as_mut() else { unreachable!() }; (l.loan_mut(zero), l.loan_mut(succ), l.loan_mut(out)) }); self.encode_term(arg, Place::Tree(node)); self.encode_term(&arms[0], Place::Hole(zero)); self.encode_term(&arms[1], Place::Hole(succ)); self.link(up, Place::Hole(out)); } Term::Let { pat, val, nxt } => { // Dups/tup eliminators are not actually scoped like other terms. // They are depended on self.lets.push((pat, val)); self.encode_term(nxt, up); } Term::Fan { fan, tag, els } => { let kind = self.fan_kind(fan, tag); self.make_node_list(kind, up, els.iter().map(|el| |slf: &mut Self, up| slf.encode_term(el, up))); } // core: & [opr] ~ $(fst $(snd ret)) Term::Oper { opr, fst, snd } => { match (fst.as_ref(), snd.as_ref()) { // Partially apply with fst (Term::Num { val }, snd) => { let val = val.to_bits(); let val = hvm::ast::Numb((val & !0x1F) | opr.to_native_tag() as u32); let fst = Place::Tree(LoanedMut::new(Tree::Num { val })); let node = self.new_opr(); self.link(fst, node.0); self.encode_term(snd, node.1); self.encode_le_ge_opers(opr, up, node.2); } // Partially apply with snd, flip (fst, Term::Num { val }) => { if let Op::POW = opr { // POW shares tags with AND, so don't flip or results will be wrong let opr_val = hvm::ast::Numb(hvm::hvm::Numb::new_sym(opr.to_native_tag()).0); let oper = Place::Tree(LoanedMut::new(Tree::Num { val: opr_val })); let node1 = self.new_opr(); self.encode_term(fst, node1.0); self.link(oper, node1.1); let node2 = self.new_opr(); self.link(node1.2, node2.0); self.encode_term(snd, node2.1); self.encode_le_ge_opers(opr, up, node2.2); } else { // flip let val = val.to_bits(); let val = hvm::ast::Numb((val & !0x1F) | flip_sym(opr.to_native_tag()) as u32); let snd = Place::Tree(LoanedMut::new(Tree::Num { val })); let node = self.new_opr(); self.encode_term(fst, node.0); self.link(snd, node.1); self.encode_le_ge_opers(opr, up, node.2); } } // Don't partially apply (fst, snd) => { let opr_val = hvm::ast::Numb(hvm::hvm::Numb::new_sym(opr.to_native_tag()).0); let oper = Place::Tree(LoanedMut::new(Tree::Num { val: opr_val })); let node1 = self.new_opr(); self.encode_term(fst, node1.0); self.link(oper, node1.1); let node2 = self.new_opr(); self.link(node1.2, node2.0); self.encode_term(snd, node2.1); self.encode_le_ge_opers(opr, up, node2.2); } } } Term::Use { .. } // Removed in earlier pass | Term::With { .. } // Removed in earlier pass | Term::Ask { .. } // Removed in earlier pass | Term::Mat { .. } // Removed in earlier pass | Term::Bend { .. } // Removed in desugar_bend | Term::Fold { .. } // Removed in desugar_fold | Term::Open { .. } // Removed in desugar_open | Term::Nat { .. } // Removed in encode_nat | Term::Str { .. } // Removed in encode_str | Term::List { .. } // Removed in encode_list | Term::Def { .. } // Removed in earlier pass | Term::Err => unreachable!(), } while let Some((pat, val)) = self.lets.pop() { let wire = self.new_wire(); self.encode_term(val, Place::Wire(wire)); self.encode_pat(pat, Place::Wire(wire)); } }) } fn encode_le_ge_opers(&mut self, opr: &Op, up: Place<'t>, node: Place<'t>) { match opr { Op::LE | Op::GE => { let node_eq = self.new_opr(); let eq_val = Place::Tree(LoanedMut::new(Tree::Num { val: hvm::ast::Numb(Op::EQ.to_native_tag() as u32) })); self.link(eq_val, node_eq.0); self.link(node_eq.1, node); self.link(up, node_eq.2); } _ => self.link(up, node), } } fn encode_pat(&mut self, pat: &Pattern, up: Place<'t>) { maybe_grow(|| match pat { Pattern::Var(None) => self.link(up, Place::Tree(LoanedMut::new(Tree::Era))), Pattern::Var(Some(name)) => self.link_var(false, name, up), Pattern::Chn(name) => self.link_var(true, name, up), Pattern::Fan(fan, tag, els) => { let kind = self.fan_kind(fan, tag); self.make_node_list(kind, up, els.iter().map(|el| |slf: &mut Self, up| slf.encode_pat(el, up))); } Pattern::Ctr(_, _) | Pattern::Num(_) | Pattern::Lst(_) | Pattern::Str(_) => unreachable!(), }) } fn link(&mut self, a: Place<'t>, b: Place<'t>) { match (a, b) { (Place::Tree(a), Place::Tree(b)) => { self.redexes.push(LoanedMut::merge((false, Tree::Era, Tree::Era), |r, m| { m.place(b, &mut r.1); m.place(a, &mut r.2); })) } (Place::Tree(t), Place::Hole(h)) | (Place::Hole(h), Place::Tree(t)) => { t.place(h); } (Place::Hole(a), Place::Hole(b)) => { let var = Tree::Var { nam: num_to_name(self.name_idx) }; self.name_idx += 1; *a = var.clone(); *b = var; } (Place::Wire(v), p) | (p, Place::Wire(v)) => { let v = &mut self.wires[v]; match v.take() { Some(q) => self.link(p, q), None => *v = Some(p), } } } } fn new_ctr(&mut self, kind: CtrKind) -> (Place<'t>, Place<'t>, Place<'t>) { self.created_nodes += 1; let node = match kind { CtrKind::Con(None) => Tree::Con { fst: Box::new(Tree::Era), snd: Box::new(Tree::Era) }, CtrKind::Dup(0) => Tree::Dup { fst: Box::new(Tree::Era), snd: Box::new(Tree::Era) }, CtrKind::Tup(None) => Tree::Con { fst: Box::new(Tree::Era), snd: Box::new(Tree::Era) }, _ => unreachable!(), }; let ((a, b), node) = LoanedMut::loan_with(node, |t, l| match t { Tree::Con { fst, snd } => (l.loan_mut(fst), l.loan_mut(snd)), Tree::Dup { fst, snd } => (l.loan_mut(fst), l.loan_mut(snd)), _ => unreachable!(), }); (Place::Tree(node), Place::Hole(a), Place::Hole(b)) } fn new_opr(&mut self) -> (Place<'t>, Place<'t>, Place<'t>) { self.created_nodes += 1; let ((fst, snd), node) = LoanedMut::loan_with(Tree::Opr { fst: Box::new(Tree::Era), snd: Box::new(Tree::Era) }, |t, l| { let Tree::Opr { fst, snd } = t else { unreachable!() }; (l.loan_mut(fst), l.loan_mut(snd)) }); (Place::Tree(node), Place::Hole(fst), Place::Hole(snd)) } /// Adds a list-like tree of nodes of the same kind to the inet. fn make_node_list( &mut self, kind: CtrKind, mut up: Place<'t>, mut els: impl DoubleEndedIterator)>, ) { let last = els.next_back().unwrap(); for item in els { let node = self.new_ctr(kind); self.link(up, node.0); item(self, node.1); up = node.2; } last(self, up); } fn new_wire(&mut self) -> usize { let i = self.wires.len(); self.wires.push(None); i } fn fan_kind(&mut self, fan: &FanKind, tag: &crate::fun::Tag) -> CtrKind { let lab = self.labels[*fan].generate(tag); if *fan == FanKind::Tup { Tup(lab) } else { Dup(lab.unwrap()) } } fn link_var(&mut self, global: bool, name: &Name, place: Place<'t>) { match self.vars.entry((global, name.clone())) { Entry::Occupied(e) => { let other = e.remove(); self.link(place, other); } Entry::Vacant(e) => { e.insert(place); } } } } #[derive(Debug, Default, Clone)] pub struct Labels { pub con: LabelGenerator, pub dup: LabelGenerator, pub tup: LabelGenerator, } #[derive(Debug, Default, Clone)] pub struct LabelGenerator { pub next: u16, pub name_to_label: HashMap, pub label_to_name: HashMap, } impl Index for Labels { type Output = LabelGenerator; fn index(&self, fan: FanKind) -> &Self::Output { match fan { FanKind::Tup => &self.tup, FanKind::Dup => &self.dup, } } } impl IndexMut for Labels { fn index_mut(&mut self, fan: FanKind) -> &mut Self::Output { match fan { FanKind::Tup => &mut self.tup, FanKind::Dup => &mut self.dup, } } } impl LabelGenerator { // If some tag and new generate a new label, otherwise return the generated label. // If none use the implicit label counter. fn generate(&mut self, tag: &crate::fun::Tag) -> Option { use crate::fun::Tag; match tag { Tag::Named(_name) => { todo!("Named tags not implemented for hvm32"); /* match self.name_to_label.entry(name.clone()) { Entry::Occupied(e) => Some(*e.get()), Entry::Vacant(e) => { let lab = unique(); self.label_to_name.insert(lab, name.clone()); Some(*e.insert(lab)) } } */ } Tag::Numeric(lab) => Some(*lab), Tag::Auto => Some(0), Tag::Static => None, } } pub fn to_tag(&self, label: Option) -> crate::fun::Tag { use crate::fun::Tag; match label { Some(label) => match self.label_to_name.get(&label) { Some(name) => Tag::Named(name.clone()), None => { if label == 0 { Tag::Auto } else { Tag::Numeric(label) } } }, None => Tag::Static, } } fn finish(&mut self) { self.next = u16::MAX; self.name_to_label.clear(); } } impl Op { fn to_native_tag(self) -> hvm::hvm::Tag { match self { Op::ADD => hvm::hvm::OP_ADD, Op::SUB => hvm::hvm::OP_SUB, Op::MUL => hvm::hvm::OP_MUL, Op::DIV => hvm::hvm::OP_DIV, Op::REM => hvm::hvm::OP_REM, Op::EQ => hvm::hvm::OP_EQ, Op::NEQ => hvm::hvm::OP_NEQ, Op::LT => hvm::hvm::OP_LT, Op::GT => hvm::hvm::OP_GT, Op::AND => hvm::hvm::OP_AND, Op::OR => hvm::hvm::OP_OR, Op::XOR => hvm::hvm::OP_XOR, Op::SHL => hvm::hvm::OP_SHL, Op::SHR => hvm::hvm::OP_SHR, Op::POW => hvm::hvm::OP_XOR, Op::LE => hvm::hvm::OP_GT, Op::GE => hvm::hvm::OP_LT, } } } fn flip_sym(tag: hvm::hvm::Tag) -> hvm::hvm::Tag { match tag { hvm::hvm::OP_SUB => hvm::hvm::FP_SUB, hvm::hvm::FP_SUB => hvm::hvm::OP_SUB, hvm::hvm::OP_DIV => hvm::hvm::FP_DIV, hvm::hvm::FP_DIV => hvm::hvm::OP_DIV, hvm::hvm::OP_REM => hvm::hvm::FP_REM, hvm::hvm::FP_REM => hvm::hvm::OP_REM, hvm::hvm::OP_LT => hvm::hvm::OP_GT, hvm::hvm::OP_GT => hvm::hvm::OP_LT, hvm::hvm::OP_SHL => hvm::hvm::FP_SHL, hvm::hvm::FP_SHL => hvm::hvm::OP_SHL, hvm::hvm::OP_SHR => hvm::hvm::FP_SHR, hvm::hvm::FP_SHR => hvm::hvm::OP_SHR, _ => tag, } } ================================================ FILE: src/fun/transform/apply_args.rs ================================================ use crate::{ diagnostics::Diagnostics, fun::{Ctx, Pattern, Rule, Term}, }; impl Ctx<'_> { /// Applies the arguments to the program being run by applying them to the main function. /// /// Example: /// ```hvm /// main x1 x2 x3 = (MainBody x1 x2 x3) /// ``` /// Calling with `bend run arg1 arg2 arg3`, it becomes: /// ```hvm /// main = (λx1 λx2 λx3 (MainBody x1 x2 x3) arg1 arg2 arg3) /// ``` pub fn apply_args(&mut self, args: Option>) -> Result<(), Diagnostics> { if let Some(entrypoint) = &self.book.entrypoint { let main_def = &mut self.book.defs[entrypoint]; // Since we fatal error, no need to exit early let n_rules = main_def.rules.len(); if n_rules != 1 { self.info.add_function_error( format!("Expected the entrypoint function to have only one rule, found {n_rules}."), entrypoint.clone(), main_def.source.clone(), ); } let mut main_body = std::mem::take(&mut main_def.rules[0].body); for pat in main_def.rules[0].pats.iter().rev() { if let Pattern::Var(var) = pat { main_body = Term::lam(Pattern::Var(var.clone()), main_body); } else { self.info.add_function_error( format!("Expected the entrypoint function to only have variable patterns, found '{pat}'."), entrypoint.clone(), main_def.source.clone(), ); } } if let Some(args) = args { main_body = Term::call(main_body, args); } main_def.rules = vec![Rule { pats: vec![], body: main_body }]; } self.info.fatal(()) } } ================================================ FILE: src/fun/transform/definition_merge.rs ================================================ use crate::{ fun::{Book, Definition, Name, Rule, Term}, maybe_grow, }; use indexmap::{IndexMap, IndexSet}; use itertools::Itertools; use std::collections::BTreeMap; pub const MERGE_SEPARATOR: &str = "__M_"; impl Book { /// Merges definitions that have the same structure into one definition. /// Expects variables to be linear. /// /// Some of the origins of the rules will be lost in this stage, /// Should not be preceded by passes that cares about the origins. pub fn merge_definitions(&mut self) { let defs: Vec<_> = self.defs.keys().cloned().collect(); self.merge(defs.into_iter()); } /// Checks and merges identical definitions given by `defs`. /// We never merge the entrypoint function with something else. fn merge(&mut self, defs: impl Iterator) { let name = self.entrypoint.clone(); // Sets of definitions that are identical, indexed by the body term. let equal_terms = self.collect_terms(defs.filter(|def_name| !name.as_ref().is_some_and(|m| m == def_name))); // Map of old name to new merged name let mut name_map = BTreeMap::new(); for (term, equal_defs) in equal_terms { // def1_$_def2_$_def3 let new_name = Name::new(equal_defs.iter().join(MERGE_SEPARATOR)); if equal_defs.len() > 1 { // Merging some defs // The source of the generated definition will be based on the first one we get from `equal_defs`. // In the future, we might want to change this to point to every source of every definition // it's based on. // This could be done by having SourceKind::Generated contain a Vec or Vec. let any_def_name = equal_defs.iter().next().unwrap(); // we know we can unwrap since equal_defs.len() > 1 // Add the merged def let source = self.defs[any_def_name].source.clone(); let rules = vec![Rule { pats: vec![], body: term }]; // Note: This will erase types, so type checking needs to come before this. let new_def = Definition::new_gen(new_name.clone(), rules, source, false); self.defs.insert(new_name.clone(), new_def); // Remove the old ones and write the map of old names to new ones. for name in equal_defs { self.defs.swap_remove(&name); name_map.insert(name, new_name.clone()); } } else { // Not merging, just put the body back let def_name = equal_defs.into_iter().next().unwrap(); let def = self.defs.get_mut(&def_name).unwrap(); def.rule_mut().body = term; } } self.update_refs(&name_map); } fn collect_terms(&mut self, def_entries: impl Iterator) -> IndexMap> { let mut equal_terms: IndexMap> = IndexMap::new(); for def_name in def_entries { let def = self.defs.get_mut(&def_name).unwrap(); let term = std::mem::take(&mut def.rule_mut().body); equal_terms.entry(term).or_default().insert(def_name); } equal_terms } fn update_refs(&mut self, name_map: &BTreeMap) { let mut updated_defs = Vec::new(); for def in self.defs.values_mut() { if Term::subst_ref_to_ref(&mut def.rule_mut().body, name_map) { updated_defs.push(def.name.clone()); } } if !updated_defs.is_empty() { self.merge(updated_defs.into_iter()); } } } impl Term { /// Performs reference substitution within a term replacing any references found in /// `ref_map` with their corresponding targets. pub fn subst_ref_to_ref(term: &mut Term, ref_map: &BTreeMap) -> bool { maybe_grow(|| match term { Term::Ref { nam: def_name } => { if let Some(target_name) = ref_map.get(def_name) { *def_name = target_name.clone(); true } else { false } } _ => { let mut subst = false; for child in term.children_mut() { subst |= Term::subst_ref_to_ref(child, ref_map); } subst } }) } } ================================================ FILE: src/fun/transform/definition_pruning.rs ================================================ use crate::{ diagnostics::WarningType, fun::{Book, Ctx, Name, SourceKind, Term}, maybe_grow, }; use hvm::ast::{Net, Tree}; use std::collections::{hash_map::Entry, HashMap}; #[derive(Clone, Copy, Debug, PartialEq)] enum Used { /// Definition is accessible from the main entry point, should never be pruned. Main, /// Definition is not accessible from main, but is accessible from non-builtin definitions. NonBuiltin, /// Definition is not accessible from main, but is a user-defined constructor. Ctr, } type Definitions = HashMap; impl Ctx<'_> { /// If `prune_all`, removes all unused definitions and adts starting from Main. /// Otherwise, prunes only the builtins not accessible from any non-built-in definition. /// /// Emits unused definition warnings. pub fn prune(&mut self, prune_all: bool) { let mut used = Definitions::new(); // Get the functions that are accessible from the main entry point. if let Some(main) = &self.book.entrypoint { let def = self.book.defs.get(main).unwrap(); used.insert(main.clone(), Used::Main); for rule in def.rules.iter() { self.book.find_used_definitions_from_term(&rule.body, Used::Main, &mut used); } } // Get the functions that are accessible from non-builtins. for def in self.book.defs.values() { if !def.is_builtin() && !(used.get(&def.name) == Some(&Used::Main)) { if self.book.ctrs.contains_key(&def.name) { used.insert(def.name.clone(), Used::Ctr); } else { used.insert(def.name.clone(), Used::NonBuiltin); } for rule in def.rules.iter() { self.book.find_used_definitions_from_term(&rule.body, Used::NonBuiltin, &mut used); } } } for def in self.book.hvm_defs.values() { if !def.source.is_builtin() && !(used.get(&def.name) == Some(&Used::Main)) { used.insert(def.name.clone(), Used::NonBuiltin); self.book.find_used_definitions_from_hvm_net(&def.body, Used::NonBuiltin, &mut used); } } fn rm_def(book: &mut Book, def_name: &Name) { if book.defs.contains_key(def_name) { book.defs.shift_remove(def_name); } else if book.hvm_defs.contains_key(def_name) { book.hvm_defs.shift_remove(def_name); } else { unreachable!() } } // Remove unused definitions. let defs = self.book.defs.iter().map(|(nam, def)| (nam.clone(), def.source.clone())); let hvm_defs = self.book.hvm_defs.iter().map(|(nam, def)| (nam.clone(), def.source.clone())); let names = defs.chain(hvm_defs).collect::>(); for (def, src) in names { if let Some(use_) = used.get(&def) { match use_ { Used::Main => { // Used by the main entry point, never pruned; } Used::NonBuiltin => { // Used by a non-builtin definition. // Prune if `prune_all`, otherwise show a warning. if prune_all { rm_def(self.book, &def); } else if !def.is_generated() && !matches!(src.kind, SourceKind::Generated) { self.info.add_function_warning( "Definition is unused.", WarningType::UnusedDefinition, def, src, ); } } Used::Ctr => { // Unused, but a user-defined constructor. // Prune if `prune_all`, otherwise nothing. if prune_all { rm_def(self.book, &def); } else { // Don't show warning if it's a user-defined constructor. } } } } else { // Unused builtin, can always be pruned. rm_def(self.book, &def); } } } } impl Book { /// Finds all used definitions on the book, starting from the given term. fn find_used_definitions_from_term(&self, term: &Term, used: Used, uses: &mut Definitions) { maybe_grow(|| { let mut to_find = vec![term]; while let Some(term) = to_find.pop() { match term { Term::Ref { nam: def_name } => self.insert_used(def_name, used, uses), Term::List { .. } => { self.insert_used(&Name::new(crate::fun::builtins::LCONS), used, uses); self.insert_used(&Name::new(crate::fun::builtins::LNIL), used, uses); } Term::Str { .. } => { self.insert_used(&Name::new(crate::fun::builtins::SCONS), used, uses); self.insert_used(&Name::new(crate::fun::builtins::SNIL), used, uses); } _ => {} } for child in term.children() { to_find.push(child); } } }) } fn find_used_definitions_from_hvm_net(&self, net: &Net, used: Used, uses: &mut Definitions) { maybe_grow(|| { let mut to_find = [&net.root] .into_iter() .chain(net.rbag.iter().flat_map(|(_, lft, rgt)| [lft, rgt])) .collect::>(); while let Some(term) = to_find.pop() { match term { Tree::Ref { nam } => self.insert_used(&Name::new(nam), used, uses), Tree::Con { fst, snd } | Tree::Dup { fst, snd } | Tree::Opr { fst, snd } | Tree::Swi { fst, snd } => { to_find.push(fst); to_find.push(snd); } Tree::Era | Tree::Var { .. } | Tree::Num { .. } => {} } } }) } fn insert_used(&self, def_name: &Name, used: Used, uses: &mut Definitions) { if let Entry::Vacant(e) = uses.entry(def_name.clone()) { e.insert(used); // This needs to be done for each rule in case the pass it's // ran from has not encoded the pattern match. // E.g.: the `flatten_rules` golden test if let Some(def) = self.defs.get(def_name) { for rule in &def.rules { self.find_used_definitions_from_term(&rule.body, used, uses); } } else if let Some(def) = self.hvm_defs.get(def_name) { self.find_used_definitions_from_hvm_net(&def.body, used, uses); } else { unreachable!() } } } } ================================================ FILE: src/fun/transform/desugar_bend.rs ================================================ use crate::{ diagnostics::Diagnostics, fun::{Ctx, Definition, Name, Rule, Source, Term}, maybe_grow, }; use indexmap::IndexMap; pub const RECURSIVE_KW: &str = "fork"; const NEW_FN_SEP: &str = "__bend"; impl Ctx<'_> { pub fn desugar_bend(&mut self) -> Result<(), Diagnostics> { let mut new_defs = IndexMap::new(); for def in self.book.defs.values_mut() { let mut fresh = 0; for rule in def.rules.iter_mut() { if let Err(err) = rule.body.desugar_bend(&def.name, &mut fresh, &mut new_defs, def.source.clone(), def.check) { self.info.add_function_error(err, def.name.clone(), def.source.clone()); break; } } } self.book.defs.extend(new_defs); self.info.fatal(()) } } impl Term { fn desugar_bend( &mut self, def_name: &Name, fresh: &mut usize, new_defs: &mut IndexMap, source: Source, check: bool, ) -> Result<(), String> { maybe_grow(|| { // Recursively encode bends in the children for child in self.children_mut() { child.desugar_bend(def_name, fresh, new_defs, source.clone(), check)?; } // Convert a bend into a new recursive function and call it. if let Term::Bend { .. } = self { // Can't have unmatched unscoped because this'll be extracted if self.has_unscoped_diff() { return Err("Can't have non self-contained unscoped variables in a 'bend'".into()); } let Term::Bend { bnd, arg, cond, step, base } = self else { unreachable!() }; let new_nam = Name::new(format!("{}{}{}", def_name, NEW_FN_SEP, fresh)); *fresh += 1; // Gather the free variables // They will be implicitly captured by the new function let mut free_vars = step.free_vars(); free_vars.shift_remove(&Name::new(RECURSIVE_KW)); free_vars.extend(base.free_vars()); free_vars.extend(cond.free_vars()); for bnd in bnd.iter().flatten() { free_vars.shift_remove(bnd); } let free_vars = free_vars.into_keys().collect::>(); // Add a substitution of `fork`, a use term with a partially applied recursive call let step = Term::Use { nam: Some(Name::new(RECURSIVE_KW)), val: Box::new(Term::call( Term::Ref { nam: new_nam.clone() }, free_vars.iter().cloned().map(|nam| Term::Var { nam }), )), nxt: Box::new(std::mem::take(step.as_mut())), }; // Create the function body for the bend. let body = Term::Swt { arg: Box::new(std::mem::take(cond)), bnd: Some(Name::new("_")), with_bnd: vec![], with_arg: vec![], pred: Some(Name::new("_-1")), arms: vec![std::mem::take(base.as_mut()), step], }; let body = Term::rfold_lams(body, std::mem::take(bnd).into_iter()); let body = Term::rfold_lams(body, free_vars.iter().cloned().map(Some)); // Make a definition from the new function let def = Definition::new_gen(new_nam.clone(), vec![Rule { pats: vec![], body }], source, check); new_defs.insert(new_nam.clone(), def); // Call the new function in the original term. let call = Term::call(Term::Ref { nam: new_nam }, free_vars.iter().map(|v| Term::Var { nam: v.clone() })); *self = Term::call(call, arg.drain(..)); } Ok(()) }) } } ================================================ FILE: src/fun/transform/desugar_fold.rs ================================================ use std::collections::HashSet; use crate::{ diagnostics::Diagnostics, fun::{Adts, Constructors, Ctx, Definition, Name, Pattern, Rule, Source, Term}, maybe_grow, }; impl Ctx<'_> { /// Desugars `fold` expressions into recursive `match`es. /// ```bend /// foo xs = /// ... /// fold bind = init with x1 x2 { /// Type/Ctr1: (Foo bind.rec_fld bind.fld x1 x2 free_var) /// Type/Ctr2: (Bar bind.fld x1 x2) /// } /// ``` /// Desugars to: /// ```bend /// foo xs = /// ... /// (foo__fold0 init x1 x2 free_var) /// /// foo__fold0 = @bind match bind { /// Type/Ctr1: (Foo (foo_fold0 bind.rec_fld x1 x2 free_var) bind.fld x1 x2 free_var) /// Type/Ctr2: (Bar bind.fld x1 x2) /// } /// ``` pub fn desugar_fold(&mut self) -> Result<(), Diagnostics> { let mut new_defs = vec![]; for def in self.book.defs.values_mut() { let mut fresh = 0; for rule in def.rules.iter_mut() { let mut ctx = DesugarFoldCtx { def_name: &def.name, fresh: &mut fresh, new_defs: &mut new_defs, ctrs: &self.book.ctrs, adts: &self.book.adts, source: def.source.clone(), check: def.check, }; let res = rule.body.desugar_fold(&mut ctx); if let Err(e) = res { self.info.add_function_error(e, def.name.clone(), def.source.clone()); } } } self.book.defs.extend(new_defs.into_iter().map(|def| (def.name.clone(), def))); self.info.fatal(()) } } struct DesugarFoldCtx<'a> { pub def_name: &'a Name, pub fresh: &'a mut usize, pub new_defs: &'a mut Vec, pub ctrs: &'a Constructors, pub adts: &'a Adts, pub source: Source, pub check: bool, } impl Term { fn desugar_fold(&mut self, ctx: &mut DesugarFoldCtx<'_>) -> Result<(), String> { maybe_grow(|| { for child in self.children_mut() { child.desugar_fold(ctx)?; } if let Term::Fold { .. } = self { // Can't have unmatched unscoped because this'll be extracted if self.has_unscoped_diff() { return Err("Can't have non self-contained unscoped variables in a 'fold'".into()); } let Term::Fold { bnd: _, arg, with_bnd, with_arg, arms } = self else { unreachable!() }; // Gather the free variables let mut free_vars = HashSet::new(); for arm in arms.iter() { let mut arm_free_vars = arm.2.free_vars().into_keys().collect::>(); for field in arm.1.iter().flatten() { arm_free_vars.remove(field); } free_vars.extend(arm_free_vars); } for var in with_bnd.iter().flatten() { free_vars.remove(var); } let free_vars = free_vars.into_iter().collect::>(); let new_nam = Name::new(format!("{}__fold{}", ctx.def_name, ctx.fresh)); *ctx.fresh += 1; // Substitute the implicit recursive calls to call the new function let ctr = arms[0].0.as_ref().unwrap(); let adt_nam = ctx.ctrs.get(ctr).unwrap(); let ctrs = &ctx.adts.get(adt_nam).unwrap().ctrs; for arm in arms.iter_mut() { let ctr = arm.0.as_ref().unwrap(); let recursive = arm .1 .iter() .zip(&ctrs.get(ctr).unwrap().fields) .filter_map(|(var, field)| if field.rec { Some(var.as_ref().unwrap().clone()) } else { None }) .collect::>(); arm.2.call_recursive(&new_nam, &recursive, &free_vars); } // Create the new function let x_nam = Name::new("%x"); let body = Term::Mat { arg: Box::new(Term::Var { nam: x_nam.clone() }), bnd: None, with_bnd: with_bnd.clone(), with_arg: with_bnd.iter().map(|nam| Term::var_or_era(nam.clone())).collect(), arms: std::mem::take(arms), }; let body = Term::rfold_lams(body, with_bnd.iter().cloned()); let body = Term::rfold_lams(body, free_vars.iter().map(|nam| Some(nam.clone()))); let body = Term::lam(Pattern::Var(Some(x_nam)), body); let def = Definition::new_gen( new_nam.clone(), vec![Rule { pats: vec![], body }], ctx.source.clone(), ctx.check, ); ctx.new_defs.push(def); // Call the new function let call = Term::call(Term::Ref { nam: new_nam.clone() }, [std::mem::take(arg.as_mut())]); let call = Term::call(call, free_vars.iter().cloned().map(|nam| Term::Var { nam })); let call = Term::call(call, with_arg.iter().cloned()); *self = call; } Ok(()) }) } fn call_recursive(&mut self, def_name: &Name, recursive: &HashSet, free_vars: &[Name]) { maybe_grow(|| { for child in self.children_mut() { child.call_recursive(def_name, recursive, free_vars); } // If we found a recursive field, replace with a call to the new function. if let Term::Var { nam } = self { if recursive.contains(nam) { let call = Term::call(Term::Ref { nam: def_name.clone() }, [std::mem::take(self)]); let call = Term::call(call, free_vars.iter().cloned().map(|nam| Term::Var { nam })); *self = call; } } }) } } ================================================ FILE: src/fun/transform/desugar_match_defs.rs ================================================ use crate::{ diagnostics::{Diagnostics, WarningType}, fun::{builtins, Adts, Constructors, Ctx, Definition, FanKind, Name, Num, Pattern, Rule, Tag, Term}, maybe_grow, }; use itertools::Itertools; use std::collections::{BTreeSet, HashSet}; pub enum DesugarMatchDefErr { AdtNotExhaustive { adt: Name, ctr: Name }, NumMissingDefault, TypeMismatch { expected: Type, found: Type, pat: Pattern }, RepeatedBind { bind: Name }, UnreachableRule { idx: usize, nam: Name, pats: Vec }, } impl Ctx<'_> { /// Converts equational-style pattern matching function definitions into trees of match terms. pub fn desugar_match_defs(&mut self) -> Result<(), Diagnostics> { for (def_name, def) in self.book.defs.iter_mut() { let errs = def.desugar_match_def(&self.book.ctrs, &self.book.adts); for err in errs { match err { DesugarMatchDefErr::AdtNotExhaustive { .. } | DesugarMatchDefErr::NumMissingDefault | DesugarMatchDefErr::TypeMismatch { .. } => { self.info.add_function_error(err, def_name.clone(), def.source.clone()) } DesugarMatchDefErr::RepeatedBind { .. } => self.info.add_function_warning( err, WarningType::RepeatedBind, def_name.clone(), def.source.clone(), ), DesugarMatchDefErr::UnreachableRule { .. } => self.info.add_function_warning( err, WarningType::UnreachableMatch, def_name.clone(), def.source.clone(), ), } } } self.info.fatal(()) } } impl Definition { pub fn desugar_match_def(&mut self, ctrs: &Constructors, adts: &Adts) -> Vec { let mut errs = vec![]; for rule in self.rules.iter_mut() { desugar_inner_match_defs(&mut rule.body, ctrs, adts, &mut errs); } let repeated_bind_errs = fix_repeated_binds(&mut self.rules); errs.extend(repeated_bind_errs); let args = (0..self.arity()).map(|i| Name::new(format!("%arg{i}"))).collect::>(); let rules = std::mem::take(&mut self.rules); let idx = (0..rules.len()).collect::>(); let mut used = BTreeSet::new(); match simplify_rule_match(args.clone(), rules.clone(), idx.clone(), vec![], &mut used, ctrs, adts) { Ok(body) => { let body = Term::rfold_lams(body, args.into_iter().map(Some)); self.rules = vec![Rule { pats: vec![], body }]; for i in idx { if !used.contains(&i) { let e = DesugarMatchDefErr::UnreachableRule { idx: i, nam: self.name.clone(), pats: rules[i].pats.clone(), }; errs.push(e); } } } Err(e) => errs.push(e), } errs } } fn desugar_inner_match_defs( term: &mut Term, ctrs: &Constructors, adts: &Adts, errs: &mut Vec, ) { maybe_grow(|| match term { Term::Def { def, nxt } => { errs.extend(def.desugar_match_def(ctrs, adts)); desugar_inner_match_defs(nxt, ctrs, adts, errs); } _ => { for child in term.children_mut() { desugar_inner_match_defs(child, ctrs, adts, errs); } } }) } /// When a rule has repeated bind, the only one that is actually useful is the last one. /// /// Example: In `(Foo x x x x) = x`, the function should return the fourth argument. /// /// To avoid having to deal with this, we can just erase any repeated binds. /// ```hvm /// (Foo a (Succ a) (Cons a)) = (a a) /// // After this transformation, becomes: /// (Foo * (Succ *) (Cons a)) = (a a) /// ``` fn fix_repeated_binds(rules: &mut [Rule]) -> Vec { let mut errs = vec![]; for rule in rules { let mut binds = HashSet::new(); rule.pats.iter_mut().flat_map(|p| p.binds_mut()).rev().for_each(|nam| { if binds.contains(nam) { // Repeated bind, not reachable and can be erased. if let Some(nam) = nam { errs.push(DesugarMatchDefErr::RepeatedBind { bind: nam.clone() }); } *nam = None; // TODO: Send a repeated bind warning } else { binds.insert(&*nam); } }); } errs } /// Creates the match tree for a given pattern matching function definition. /// For each constructor, a match case is created. /// /// The match cases follow the same order as the order the constructors are in /// the ADT declaration. /// /// If there are constructors of different types for the same arg, returns a type error. /// /// If no patterns match one of the constructors, returns a non-exhaustive match error. /// /// Any nested subpatterns are extracted and moved into a nested match /// expression, together with the remaining match arguments. /// /// Linearizes all the arguments that are used in at least one of the bodies. /// /// `args`: Name of the generated argument variables that sill have to be processed. /// `rules`: The rules to simplify. /// `idx`: The original index of the rules, to check for unreachable rules. /// `with`: Name of the variables to be inserted in the `with` clauses. fn simplify_rule_match( args: Vec, rules: Vec, idx: Vec, with: Vec, used: &mut BTreeSet, ctrs: &Constructors, adts: &Adts, ) -> Result { if args.is_empty() { used.insert(idx[0]); Ok(rules.into_iter().next().unwrap().body) } else if rules[0].pats.iter().all(|p| p.is_wildcard()) { Ok(irrefutable_fst_row_rule(args, rules.into_iter().next().unwrap(), idx[0], used)) } else { let typ = Type::infer_from_def_arg(&rules, 0, ctrs)?; match typ { Type::Any => var_rule(args, rules, idx, with, used, ctrs, adts), Type::Fan(fan, tag, tup_len) => fan_rule(args, rules, idx, with, used, fan, tag, tup_len, ctrs, adts), Type::Num => num_rule(args, rules, idx, with, used, ctrs, adts), Type::Adt(adt_name) => switch_rule(args, rules, idx, with, adt_name, used, ctrs, adts), } } } /// Irrefutable first row rule. /// Short-circuits the encoding in case the first rule always matches. /// This is useful to avoid unnecessary pattern matching. fn irrefutable_fst_row_rule(args: Vec, rule: Rule, idx: usize, used: &mut BTreeSet) -> Term { let mut term = rule.body; for (arg, pat) in args.into_iter().zip(rule.pats.into_iter()) { match pat { Pattern::Var(None) => {} Pattern::Var(Some(var)) => { term = Term::Use { nam: Some(var), val: Box::new(Term::Var { nam: arg }), nxt: Box::new(term) }; } Pattern::Chn(var) => { term = Term::Let { pat: Box::new(Pattern::Chn(var)), val: Box::new(Term::Var { nam: arg }), nxt: Box::new(term), }; } _ => unreachable!(), } } used.insert(idx); term } /// Var rule. /// `case x0 ... xN { var p1 ... pN: (Body var p1 ... pN) }` /// becomes /// `case x1 ... xN { p1 ... pN: use var = x0; (Body var p1 ... pN) }` fn var_rule( mut args: Vec, rules: Vec, idx: Vec, mut with: Vec, used: &mut BTreeSet, ctrs: &Constructors, adts: &Adts, ) -> Result { let arg = args[0].clone(); let new_args = args.split_off(1); let mut new_rules = vec![]; for mut rule in rules { let new_pats = rule.pats.split_off(1); let pat = rule.pats.pop().unwrap(); if let Pattern::Var(Some(nam)) = &pat { rule.body = Term::Use { nam: Some(nam.clone()), val: Box::new(Term::Var { nam: arg.clone() }), nxt: Box::new(std::mem::take(&mut rule.body)), }; } let new_rule = Rule { pats: new_pats, body: rule.body }; new_rules.push(new_rule); } with.push(arg); simplify_rule_match(new_args, new_rules, idx, with, used, ctrs, adts) } /// Tuple rule. /// ```hvm /// case x0 ... xN { /// (p0_0, ... p0_M) p1 ... pN: /// (Body p0_0 ... p0_M p1 ... pN) /// } /// ``` /// becomes /// ```hvm /// let (x0.0, ... x0.M) = x0; /// case x0.0 ... x0.M x1 ... xN { /// p0_0 ... p0_M p1 ... pN: /// (Body p0_0 ... p0_M p1 ... pN) /// } /// ``` #[allow(clippy::too_many_arguments)] fn fan_rule( mut args: Vec, rules: Vec, idx: Vec, with: Vec, used: &mut BTreeSet, fan: FanKind, tag: Tag, len: usize, ctrs: &Constructors, adts: &Adts, ) -> Result { let arg = args[0].clone(); let old_args = args.split_off(1); let new_args = (0..len).map(|i| Name::new(format!("{arg}.{i}"))); let mut new_rules = vec![]; for mut rule in rules { let pat = rule.pats[0].clone(); let old_pats = rule.pats.split_off(1); // Extract subpatterns from the tuple pattern let mut new_pats = match pat { Pattern::Fan(.., sub_pats) => sub_pats, Pattern::Var(var) => { if let Some(var) = var { // Rebuild the tuple if it was a var pattern let tup = Term::Fan { fan, tag: tag.clone(), els: new_args.clone().map(|nam| Term::Var { nam }).collect() }; rule.body = Term::Use { nam: Some(var), val: Box::new(tup), nxt: Box::new(std::mem::take(&mut rule.body)) }; } new_args.clone().map(|nam| Pattern::Var(Some(nam))).collect() } _ => unreachable!(), }; new_pats.extend(old_pats); let new_rule = Rule { pats: new_pats, body: rule.body }; new_rules.push(new_rule); } let bnd = new_args.clone().map(|x| Pattern::Var(Some(x))).collect(); let args = new_args.chain(old_args).collect(); let nxt = simplify_rule_match(args, new_rules, idx, with, used, ctrs, adts)?; let term = Term::Let { pat: Box::new(Pattern::Fan(fan, tag.clone(), bnd)), val: Box::new(Term::Var { nam: arg }), nxt: Box::new(nxt), }; Ok(term) } fn num_rule( mut args: Vec, rules: Vec, idx: Vec, with: Vec, used: &mut BTreeSet, ctrs: &Constructors, adts: &Adts, ) -> Result { // Number match must always have a default case if !rules.iter().any(|r| r.pats[0].is_wildcard()) { return Err(DesugarMatchDefErr::NumMissingDefault); } let arg = args[0].clone(); let args = args.split_off(1); let pred_var = Name::new(format!("{arg}-1")); // Since numbers have infinite (2^60) constructors, they require special treatment. // We first iterate over each present number then get the default. let nums = rules .iter() .filter_map(|r| if let Pattern::Num(n) = r.pats[0] { Some(n) } else { None }) .collect::>() .into_iter() .collect::>(); // Number cases let mut num_bodies = vec![]; for num in nums.iter() { let mut new_rules = vec![]; let mut new_idx = vec![]; for (rule, &idx) in rules.iter().zip(&idx) { match &rule.pats[0] { Pattern::Num(n) if n == num => { let body = rule.body.clone(); let rule = Rule { pats: rule.pats[1..].to_vec(), body }; new_rules.push(rule); new_idx.push(idx); } Pattern::Var(var) => { let mut body = rule.body.clone(); if let Some(var) = var { body = Term::Use { nam: Some(var.clone()), val: Box::new(Term::Num { val: Num::U24(*num) }), nxt: Box::new(std::mem::take(&mut body)), }; } let rule = Rule { pats: rule.pats[1..].to_vec(), body }; new_rules.push(rule); new_idx.push(idx); } _ => (), } } let body = simplify_rule_match(args.clone(), new_rules, new_idx, with.clone(), used, ctrs, adts)?; num_bodies.push(body); } // Default case let mut new_rules = vec![]; let mut new_idx = vec![]; for (rule, &idx) in rules.into_iter().zip(&idx) { if let Pattern::Var(var) = &rule.pats[0] { let mut body = rule.body.clone(); if let Some(var) = var { let last_num = *nums.last().unwrap(); let cur_num = 1 + last_num; let var_recovered = Term::add_num(Term::Var { nam: pred_var.clone() }, Num::U24(cur_num)); body = Term::Use { nam: Some(var.clone()), val: Box::new(var_recovered), nxt: Box::new(body) }; fast_pred_access(&mut body, cur_num, var, &pred_var); } let rule = Rule { pats: rule.pats[1..].to_vec(), body }; new_rules.push(rule); new_idx.push(idx); } } let mut default_with = with.clone(); default_with.push(pred_var.clone()); let default_body = simplify_rule_match(args.clone(), new_rules, new_idx, default_with, used, ctrs, adts)?; // Linearize previously matched vars and current args. let with = with.into_iter().chain(args).collect::>(); let with_bnd = with.iter().cloned().map(Some).collect::>(); let with_arg = with.iter().cloned().map(|nam| Term::Var { nam }).collect::>(); let term = num_bodies.into_iter().enumerate().rfold(default_body, |term, (i, body)| { let val = if i > 0 { // switch arg = (pred +1 +num_i-1 - num_i) { 0: body_i; _: acc } // nums[i] >= nums[i-1]+1, so we do a sub here. Term::sub_num(Term::Var { nam: pred_var.clone() }, Num::U24(nums[i] - 1 - nums[i - 1])) } else { // switch arg = (arg -num_0) { 0: body_0; _: acc} Term::sub_num(Term::Var { nam: arg.clone() }, Num::U24(nums[i])) }; Term::Swt { arg: Box::new(val), bnd: Some(arg.clone()), with_bnd: with_bnd.clone(), with_arg: with_arg.clone(), pred: Some(pred_var.clone()), arms: vec![body, term], } }); Ok(term) } /// Replaces `body` to `pred_var` if the term is a operation that subtracts the given var by the current /// switch number. fn fast_pred_access(body: &mut Term, cur_num: u32, var: &Name, pred_var: &Name) { maybe_grow(|| { if let Term::Oper { opr: crate::fun::Op::SUB, fst, snd } = body { if let Term::Num { val: crate::fun::Num::U24(val) } = &**snd { if let Term::Var { nam } = &**fst { if nam == var && *val == cur_num { *body = Term::Var { nam: pred_var.clone() }; } } } } for child in body.children_mut() { fast_pred_access(child, cur_num, var, pred_var) } }) } /// When the first column has constructors, create a branch on the constructors /// of the first arg. /// /// The extracted nested patterns and remaining args are handled recursively in /// a nested expression for each match arm. /// /// If we imagine a complex match expression representing what's left of the /// encoding of a pattern matching function: /// ```hvm /// data MyType = (CtrA ctrA_field0 ... ctrA_fieldA) | (CtrB ctrB_field0 ... ctrB_fieldB) | CtrC | ... /// /// case x0 ... xN { /// (CtrA p0_0_0 ... p0_A) p0_1 ... p0_N : (Body0 p0_0_0 ... p0_0_A p0_1 ... p0_N) /// ... /// varI pI_1 ... pI_N: (BodyI varI pI_1 ... pI_N) /// ... /// (CtrB pJ_0_0 ... pJ_0_B) pJ_1 ... pJ_N: (BodyJ pJ_0_0 ... pJ_0_B pJ_1 ... pJ_N) /// ... /// (CtrC) pK_1 ... pK_N: (BodyK p_1 ... pK_N) /// ... /// } /// ``` /// is converted into /// ```hvm /// match x0 { /// CtrA: case x.ctrA_field0 ... x.ctrA_fieldA x1 ... xN { /// p0_0_0 ... p0_0_B p0_1 ... p0_N : /// (Body0 p0_0_0 ... p0_0_B ) /// x.ctrA_field0 ... x.ctrA_fieldA pI_1 ... pI_N: /// use varI = (CtrA x.ctrA_field0 ... x.ctrA_fieldN); (BodyI varI pI_1 ... pI_N) /// ... /// } /// CtrB: case x.ctrB_field0 ... x.ctrB_fieldB x1 ... xN { /// x.ctrB_field0 ... x.ctrB_fieldB pI_1 ... pI_N: /// use varI = (CtrB x.ctrB_field0 ... x.ctrB_fieldB); (BodyI varI pI_1 ... pI_N) /// pJ_0_0 ... pJ_0_B pJ_1 ... pJ_N : /// (BodyJ pJ_0_0 ... pJ_0_B pJ_1 ... pJ_N) /// ... /// } /// CtrC: case * x1 ... xN { /// * pI_1 ... pI_N: /// use varI = CtrC; (BodyI varI pI_1 ... pI_N) /// * pK_1 ... pK_N: /// (BodyK p_1 ... pK_N) /// ... /// } /// ... /// } /// ``` /// Where `case` represents a call of the [`simplify_rule_match`] function. #[allow(clippy::too_many_arguments)] fn switch_rule( mut args: Vec, rules: Vec, idx: Vec, with: Vec, adt_name: Name, used: &mut BTreeSet, ctrs: &Constructors, adts: &Adts, ) -> Result { let arg = args[0].clone(); let old_args = args.split_off(1); let mut new_arms = vec![]; for (ctr_nam, ctr) in &adts[&adt_name].ctrs { let new_args = ctr.fields.iter().map(|f| Name::new(format!("{}.{}", arg, f.nam))); let args = new_args.clone().chain(old_args.clone()).collect(); let mut new_rules = vec![]; let mut new_idx = vec![]; for (rule, &idx) in rules.iter().zip(&idx) { let old_pats = rule.pats[1..].to_vec(); match &rule.pats[0] { // Same ctr, extract subpatterns. // (Ctr pat0_0 ... pat0_m) pat1 ... patN: body // becomes // pat0_0 ... pat0_m pat1 ... patN: body Pattern::Ctr(found_ctr, new_pats) if ctr_nam == found_ctr => { let pats = new_pats.iter().cloned().chain(old_pats).collect(); let body = rule.body.clone(); let rule = Rule { pats, body }; new_rules.push(rule); new_idx.push(idx); } // Var, match and rebuild the constructor. // var pat1 ... patN: body // becomes // arg0.field0 ... arg0.fieldM pat1 ... patN: // use var = (Ctr arg0.field0 ... arg0.fieldM); body Pattern::Var(var) => { let new_pats = new_args.clone().map(|n| Pattern::Var(Some(n))); let pats = new_pats.chain(old_pats.clone()).collect(); let mut body = rule.body.clone(); let reconstructed_var = Term::call(Term::Ref { nam: ctr_nam.clone() }, new_args.clone().map(|nam| Term::Var { nam })); if let Some(var) = var { body = Term::Use { nam: Some(var.clone()), val: Box::new(reconstructed_var), nxt: Box::new(body) }; } let rule = Rule { pats, body }; new_rules.push(rule); new_idx.push(idx); } _ => (), } } if new_rules.is_empty() { return Err(DesugarMatchDefErr::AdtNotExhaustive { adt: adt_name, ctr: ctr_nam.clone() }); } let body = simplify_rule_match(args, new_rules, new_idx, with.clone(), used, ctrs, adts)?; new_arms.push((Some(ctr_nam.clone()), new_args.map(Some).collect(), body)); } // Linearize previously matched vars and current args. let with = with.into_iter().chain(old_args).collect::>(); let with_bnd = with.iter().cloned().map(Some).collect::>(); let with_arg = with.iter().cloned().map(|nam| Term::Var { nam }).collect::>(); let term = Term::Mat { arg: Box::new(Term::Var { nam: arg.clone() }), bnd: Some(arg.clone()), with_bnd, with_arg, arms: new_arms, }; Ok(term) } /// Pattern types. #[derive(Debug, Clone, PartialEq, Eq)] pub enum Type { /// Variables/wildcards. Any, /// A native tuple. Fan(FanKind, Tag, usize), /// A sequence of arbitrary numbers ending in a variable. Num, /// Adt constructors declared with the `data` syntax. Adt(Name), } impl Type { // Infers the type of a column of a pattern matrix, from the rules of a function def. fn infer_from_def_arg( rules: &[Rule], arg_idx: usize, ctrs: &Constructors, ) -> Result { let pats = rules.iter().map(|r| &r.pats[arg_idx]); let mut arg_type = Type::Any; for pat in pats { arg_type = match (arg_type, pat.to_type(ctrs)) { (Type::Any, found) => found, (expected, Type::Any) => expected, (expected, found) if expected == found => expected, (expected, found) => { return Err(DesugarMatchDefErr::TypeMismatch { expected, found, pat: pat.clone() }); } }; } Ok(arg_type) } } impl Pattern { fn to_type(&self, ctrs: &Constructors) -> Type { match self { Pattern::Var(_) | Pattern::Chn(_) => Type::Any, Pattern::Ctr(ctr_nam, _) => { let adt_nam = ctrs.get(ctr_nam).unwrap_or_else(|| panic!("Unknown constructor '{ctr_nam}'")); Type::Adt(adt_nam.clone()) } Pattern::Fan(is_tup, tag, args) => Type::Fan(*is_tup, tag.clone(), args.len()), Pattern::Num(_) => Type::Num, Pattern::Lst(..) => Type::Adt(Name::new(builtins::LIST)), Pattern::Str(..) => Type::Adt(Name::new(builtins::STRING)), } } } impl std::fmt::Display for Type { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Type::Any => write!(f, "any"), Type::Fan(FanKind::Tup, tag, n) => write!(f, "{}{n}-tuple", tag.display_padded()), Type::Fan(FanKind::Dup, tag, n) => write!(f, "{}{n}-dup", tag.display_padded()), Type::Num => write!(f, "number"), Type::Adt(nam) => write!(f, "{nam}"), } } } impl std::fmt::Display for DesugarMatchDefErr { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { DesugarMatchDefErr::AdtNotExhaustive { adt, ctr } => { write!(f, "Non-exhaustive pattern matching rule. Constructor '{ctr}' of type '{adt}' not covered") } DesugarMatchDefErr::TypeMismatch { expected, found, pat } => { write!( f, "Type mismatch in pattern matching rule. Expected a constructor of type '{}', found '{}' with type '{}'.", expected, pat, found ) } DesugarMatchDefErr::NumMissingDefault => { write!(f, "Non-exhaustive pattern matching rule. Default case of number type not covered.") } DesugarMatchDefErr::RepeatedBind { bind } => { write!(f, "Repeated bind in pattern matching rule: '{bind}'.") } DesugarMatchDefErr::UnreachableRule { idx, nam, pats } => { write!( f, "Unreachable pattern matching rule '({}{})' (rule index {idx}).", nam, pats.iter().map(|p| format!(" {p}")).join("") ) } } } } ================================================ FILE: src/fun/transform/desugar_open.rs ================================================ use crate::{ diagnostics::Diagnostics, fun::{Adts, Ctx, Term}, maybe_grow, }; impl Ctx<'_> { pub fn desugar_open(&mut self) -> Result<(), Diagnostics> { for def in self.book.defs.values_mut() { for rule in def.rules.iter_mut() { if let Err(err) = rule.body.desugar_open(&self.book.adts) { self.info.add_function_error(err, def.name.clone(), def.source.clone()); } } } self.info.fatal(()) } } impl Term { fn desugar_open(&mut self, adts: &Adts) -> Result<(), String> { maybe_grow(|| { match self { Term::Open { typ, var, bod } => { bod.desugar_open(adts)?; if let Some(adt) = adts.get(&*typ) { if adt.ctrs.len() == 1 { let ctr = adt.ctrs.keys().next().unwrap(); *self = Term::Mat { arg: Box::new(Term::Var { nam: var.clone() }), bnd: Some(std::mem::take(var)), with_bnd: vec![], with_arg: vec![], arms: vec![(Some(ctr.clone()), vec![], std::mem::take(bod))], } } else { return Err(format!("Type '{typ}' of an 'open' has more than one constructor")); } } else { return Err(format!("Type '{typ}' of an 'open' is not defined")); } } Term::Def { def, nxt } => { for rule in def.rules.iter_mut() { rule.body.desugar_open(adts)?; } nxt.desugar_open(adts)?; } _ => { for child in self.children_mut() { child.desugar_open(adts)?; } } } Ok(()) }) } } ================================================ FILE: src/fun/transform/desugar_use.rs ================================================ use crate::{ fun::{Book, Term}, maybe_grow, }; impl Book { /// Inline copies of the declared bind in the `use` expression. /// /// Example: /// ```bend /// use id = λx x /// (id id id) /// /// // Transforms to: /// (λx x λx x λx x) /// ``` pub fn desugar_use(&mut self) { for def in self.defs.values_mut() { for rule in def.rules.iter_mut() { rule.body.desugar_use(); } } } /// Inline copies of the declared bind in `Fold`, `Mat` and `Open` inside `use` expressions. pub fn desugar_ctr_use(&mut self) { for def in self.defs.values_mut() { for rule in def.rules.iter_mut() { rule.body.desugar_ctr_use(); } } } } impl Term { pub fn desugar_use(&mut self) { maybe_grow(|| { for children in self.children_mut() { children.desugar_use(); } }); if let Term::Use { nam: Some(nam), val, nxt } = self { nxt.subst(nam, val); *self = std::mem::take(nxt); } } pub fn desugar_ctr_use(&mut self) { maybe_grow(|| { for children in self.children_mut() { children.desugar_ctr_use(); } }); if let Term::Use { nam: Some(nam), val, nxt } = self { if let Term::Var { nam: val } = val.as_ref() { nxt.subst_ctrs(nam, val); } } } } ================================================ FILE: src/fun/transform/desugar_with_blocks.rs ================================================ use crate::{ diagnostics::Diagnostics, fun::{Ctx, Name, Pattern, Term}, maybe_grow, }; use std::collections::HashSet; impl Ctx<'_> { /// Converts `ask` terms inside `with` blocks into calls to a monadic bind operation. pub fn desugar_with_blocks(&mut self) -> Result<(), Diagnostics> { let def_names = self.book.defs.keys().cloned().collect::>(); for def in self.book.defs.values_mut() { for rule in def.rules.iter_mut() { if let Err(e) = rule.body.desugar_with_blocks(None, &def_names) { self.info.add_function_error(e, def.name.clone(), def.source.clone()); } } } self.info.fatal(()) } } impl Term { pub fn desugar_with_blocks( &mut self, cur_block: Option<&Name>, def_names: &HashSet, ) -> Result<(), String> { maybe_grow(|| { if let Term::With { typ, bod } = self { bod.desugar_with_blocks(Some(typ), def_names)?; let wrap_ref = Term::r#ref(&format!("{typ}/wrap")); *self = Term::Use { nam: Some(Name::new("wrap")), val: Box::new(wrap_ref), nxt: std::mem::take(bod) }; } if let Term::Ask { pat, val, nxt } = self { if let Some(typ) = cur_block { let bind_nam = Name::new(format!("{typ}/bind")); if def_names.contains(&bind_nam) { let nxt = Term::lam(*pat.clone(), std::mem::take(nxt)); let nxt = nxt.defer(); *self = Term::call(Term::Ref { nam: bind_nam }, [*val.clone(), nxt]); } else { return Err(format!("Could not find definition {bind_nam} for type {typ}.")); } } else { return Err(format!("Monadic bind operation '{pat} <- ...' used outside of a `do` block.")); } } for children in self.children_mut() { children.desugar_with_blocks(cur_block, def_names)?; } Ok(()) }) } /// Converts a term with free vars `(f x1 .. xn)` into a deferred /// call that passes those vars to the term. /// /// Ex: `(f x1 .. xn)` becomes `@x (x @x1 .. @xn (f x1 .. x2) x1 .. x2)`. /// /// The user must call this lazy thunk by calling the builtin /// `undefer` function, or by applying `@x x` to the term. fn defer(self) -> Term { let free_vars = self.free_vars().into_keys().collect::>(); let term = Term::rfold_lams(self, free_vars.iter().cloned().map(Some)); let term = Term::call(Term::Var { nam: Name::new("%x") }, [term]); let term = Term::call(term, free_vars.iter().cloned().map(|nam| Term::Var { nam })); Term::lam(Pattern::Var(Some(Name::new("%x"))), term) } } ================================================ FILE: src/fun/transform/encode_adts.rs ================================================ use crate::{ fun::{Book, Definition, Name, Num, Pattern, Rule, Source, Term}, AdtEncoding, }; impl Book { /// Defines a function for each constructor in each ADT in the book. pub fn encode_adts(&mut self, adt_encoding: AdtEncoding) { let mut defs = vec![]; for (_, adt) in self.adts.iter() { for (ctr_idx, (ctr_name, ctr)) in adt.ctrs.iter().enumerate() { let ctrs: Vec<_> = adt.ctrs.keys().cloned().collect(); let body = match adt_encoding { AdtEncoding::Scott => encode_ctr_scott(ctr.fields.iter().map(|f| &f.nam), ctrs, ctr_name), AdtEncoding::NumScott => { let tag = encode_num_scott_tag(ctr_idx as u32, ctr_name, adt.source.clone()); defs.push((tag.name.clone(), tag.clone())); encode_ctr_num_scott(ctr.fields.iter().map(|f| &f.nam), &tag.name) } }; let rules = vec![Rule { pats: vec![], body }]; let def = Definition { name: ctr_name.clone(), typ: ctr.typ.clone(), check: true, rules, source: adt.source.clone(), }; defs.push((ctr_name.clone(), def)); } } self.defs.extend(defs); } } fn encode_ctr_scott<'a>( ctr_args: impl DoubleEndedIterator + Clone, ctrs: Vec, ctr_name: &Name, ) -> Term { let ctr = Term::Var { nam: ctr_name.clone() }; let app = Term::call(ctr, ctr_args.clone().cloned().map(|nam| Term::Var { nam })); let lam = Term::rfold_lams(app, ctrs.into_iter().map(Some)); Term::rfold_lams(lam, ctr_args.cloned().map(Some)) } fn encode_ctr_num_scott<'a>(ctr_args: impl DoubleEndedIterator + Clone, tag: &str) -> Term { let nam = Name::new("%x"); // λa1 .. λan λx (x TAG a1 .. an) let term = Term::Var { nam: nam.clone() }; let tag = Term::r#ref(tag); let term = Term::app(term, tag); let term = Term::call(term, ctr_args.clone().cloned().map(|nam| Term::Var { nam })); let term = Term::lam(Pattern::Var(Some(nam)), term); Term::rfold_lams(term, ctr_args.cloned().map(Some)) } fn encode_num_scott_tag(tag: u32, ctr_name: &Name, source: Source) -> Definition { let tag_nam = Name::new(format!("{ctr_name}/tag")); let rules = vec![Rule { pats: vec![], body: Term::Num { val: Num::U24(tag) } }]; Definition::new_gen(tag_nam.clone(), rules, source, true) } ================================================ FILE: src/fun/transform/encode_match_terms.rs ================================================ use crate::{ fun::{Book, MatchRule, Name, Pattern, Term}, maybe_grow, AdtEncoding, }; impl Book { /// Encodes pattern matching expressions in the book into their /// core form. Must be run after [`Ctr::fix_match_terms`]. /// /// ADT matches are encoded based on `adt_encoding`. /// /// Num matches are encoded as a sequence of native num matches (on 0 and 1+). pub fn encode_matches(&mut self, adt_encoding: AdtEncoding) { for def in self.defs.values_mut() { for rule in &mut def.rules { rule.body.encode_matches(adt_encoding); } } } } impl Term { pub fn encode_matches(&mut self, adt_encoding: AdtEncoding) { maybe_grow(|| { for child in self.children_mut() { child.encode_matches(adt_encoding) } if let Term::Mat { arg, bnd: _, with_bnd, with_arg, arms } = self { assert!(with_bnd.is_empty()); assert!(with_arg.is_empty()); let arg = std::mem::take(arg.as_mut()); let rules = std::mem::take(arms); *self = encode_match(arg, rules, adt_encoding); } else if let Term::Swt { arg, bnd: _, with_bnd, with_arg, pred, arms } = self { assert!(with_bnd.is_empty()); assert!(with_arg.is_empty()); let arg = std::mem::take(arg.as_mut()); let pred = std::mem::take(pred); let rules = std::mem::take(arms); *self = encode_switch(arg, pred, rules); } }) } } fn encode_match(arg: Term, rules: Vec, adt_encoding: AdtEncoding) -> Term { match adt_encoding { AdtEncoding::Scott => { let arms = rules.into_iter().map(|rule| Term::rfold_lams(rule.2, rule.1.into_iter())); Term::call(arg, arms) } AdtEncoding::NumScott => { fn make_switches(arms: &mut [Term]) -> Term { maybe_grow(|| match arms { [] => Term::Err, [arm] => Term::lam(Pattern::Var(None), std::mem::take(arm)), [arm, rest @ ..] => Term::lam( Pattern::Var(Some(Name::new("%tag"))), Term::Swt { arg: Box::new(Term::Var { nam: Name::new("%tag") }), bnd: None, with_bnd: vec![], with_arg: vec![], pred: None, arms: vec![std::mem::take(arm), make_switches(rest)], }, ), }) } let mut arms = rules.into_iter().map(|rule| Term::rfold_lams(rule.2, rule.1.into_iter())).collect::>(); let term = if arms.len() == 1 { // λx (x λtag switch tag {0: Ctr0; _: * }) let arm = arms.pop().unwrap(); let term = Term::Swt { arg: Box::new(Term::Var { nam: Name::new("%tag") }), bnd: None, with_bnd: vec![], with_arg: vec![], pred: None, arms: vec![arm, Term::Era], }; Term::lam(Pattern::Var(Some(Name::new("%tag"))), term) } else { // λx (x λtag switch tag {0: Ctr0; _: switch tag-1 { ... } }) make_switches(arms.as_mut_slice()) }; Term::call(arg, [term]) } } } /// Convert into a sequence of native switches, decrementing by 1 each switch. /// switch n {0: A; 1: B; _: (C n-2)} converted to /// switch n {0: A; _: @%x match %x {0: B; _: @n-2 (C n-2)}} fn encode_switch(arg: Term, pred: Option, mut rules: Vec) -> Term { // Create the cascade of switches let match_var = Name::new("%x"); let (succ, nums) = rules.split_last_mut().unwrap(); let last_arm = Term::lam(Pattern::Var(pred), std::mem::take(succ)); nums.iter_mut().enumerate().rfold(last_arm, |term, (i, rule)| { let arms = vec![std::mem::take(rule), term]; if i == 0 { Term::Swt { arg: Box::new(arg.clone()), bnd: None, with_bnd: vec![], with_arg: vec![], pred: None, arms, } } else { let swt = Term::Swt { arg: Box::new(Term::Var { nam: match_var.clone() }), bnd: None, with_bnd: vec![], with_arg: vec![], pred: None, arms, }; Term::lam(Pattern::Var(Some(match_var.clone())), swt) } }) } ================================================ FILE: src/fun/transform/expand_generated.rs ================================================ use std::collections::{BTreeSet, HashMap, HashSet}; use crate::{ fun::{Book, Name, Term}, maybe_grow, }; /// Dereferences any non recursive generated definitions in the term. /// Used after readback. impl Term { pub fn expand_generated(&mut self, book: &Book, recursive_defs: &RecursiveDefs) { maybe_grow(|| { if let Term::Ref { nam } = &*self { if nam.is_generated() && !recursive_defs.contains(nam) { *self = book.defs.get(nam).unwrap().rule().body.clone(); } } for child in self.children_mut() { child.expand_generated(book, recursive_defs); } }) } } type DepGraph = HashMap>; type Cycles = Vec>; type RecursiveDefs = BTreeSet; impl Book { pub fn recursive_defs(&self) -> RecursiveDefs { let mut cycle_map = BTreeSet::new(); let deps = book_def_deps(self); let cycles = cycles(&deps); for cycle in cycles { for name in cycle { cycle_map.insert(name); } } cycle_map } } /// Find all cycles in the dependency graph. fn cycles(deps: &DepGraph) -> Cycles { let mut cycles = vec![]; let mut visited = HashSet::new(); // let mut stack = vec![]; for nam in deps.keys() { if !visited.contains(nam) { find_cycles(deps, nam, &mut visited, &mut cycles); } } cycles } fn find_cycles(deps: &DepGraph, nam: &Name, visited: &mut HashSet, cycles: &mut Cycles) { let mut stack = vec![(nam.clone(), vec![])]; while let Some((current, path)) = stack.pop() { if visited.contains(¤t) { // Check if the current ref is already in the stack, which indicates a cycle. if let Some(cycle_start) = path.iter().position(|n| n == ¤t) { // If found, add the cycle to the cycles vector. cycles.push(path[cycle_start..].to_vec()); } continue; } // If the ref has not been visited yet, mark it as visited. visited.insert(current.clone()); // Add the current ref to the stack to keep track of the path. let mut new_path = path.clone(); new_path.push(current.clone()); // Search for cycles from each dependency. if let Some(deps) = deps.get(¤t) { for dep in deps { stack.push((dep.clone(), new_path.clone())); } } } } fn book_def_deps(book: &Book) -> DepGraph { book.defs.iter().map(|(nam, def)| (nam.clone(), def_deps(def))).collect() } fn def_deps(def: &crate::fun::Definition) -> HashSet { fn collect_refs(term: &Term, set: &mut HashSet) { if let Term::Ref { nam } = term { set.insert(nam.clone()); } for children in term.children() { collect_refs(children, set); } } let mut set = HashSet::new(); let term = &def.rule().body; collect_refs(term, &mut set); set } ================================================ FILE: src/fun/transform/expand_main.rs ================================================ use crate::{ fun::{Book, Name, Pattern, Term}, maybe_grow, }; use std::collections::HashMap; impl Book { /// Expands the main function so that it is not just a reference. /// While technically correct, directly returning a reference is never what users want. pub fn expand_main(&mut self) { if self.entrypoint.is_none() { return; } let main = self.defs.get_mut(self.entrypoint.as_ref().unwrap()).unwrap(); let mut main_bod = std::mem::take(&mut main.rule_mut().body); let mut seen = vec![self.entrypoint.as_ref().unwrap().clone()]; main_bod.expand_ref_return(self, &mut seen, &mut 0); // Undo the `float_combinators` pass for main, to recover the strictness of the main function. main_bod.expand_floated_combinators(self); let main = self.defs.get_mut(self.entrypoint.as_ref().unwrap()).unwrap(); main.rule_mut().body = main_bod; } } impl Term { /// Expands references in the main function that are in "return" position. /// /// This applies to: /// - When main returns a reference. /// - When main returns a lambda whose body is a reference. /// - When main returns a pair or superposition and one of its elements is a reference. /// /// Only expand recursive functions once. fn expand_ref_return(&mut self, book: &Book, seen: &mut Vec, globals_count: &mut usize) { maybe_grow(|| match self { Term::Ref { nam } => { if seen.contains(nam) { // Don't expand recursive references } else if let Some(def) = book.defs.get(nam) { // Regular function, expand seen.push(nam.clone()); let mut body = def.rule().body.clone(); body.rename_unscoped(globals_count, &mut HashMap::new()); *self = body; self.expand_ref_return(book, seen, globals_count); seen.pop().unwrap(); } else { // Not a regular function, don't expand } } Term::Fan { els, .. } | Term::List { els } => { for el in els { el.expand_ref_return(book, seen, globals_count); } } // If an application is just a constructor, we expand the arguments. // That way we can write programs like // `main = [do_thing1, do_thing2, do_thing3]` Term::App { .. } => { let (fun, args) = self.multi_arg_app(); if let Term::Ref { nam } = fun { if book.ctrs.contains_key(nam) { for arg in args { // If the argument is a 0-ary constructor, we don't need to expand it. if let Term::Ref { nam } = arg { if let Some(adt_nam) = book.ctrs.get(nam) { if book.adts.get(adt_nam).unwrap().ctrs.get(nam).unwrap().fields.is_empty() { continue; } } } // Otherwise, we expand the argument. arg.expand_ref_return(book, seen, globals_count); } } } } Term::Lam { bod: nxt, .. } | Term::With { bod: nxt, .. } | Term::Open { bod: nxt, .. } | Term::Let { nxt, .. } | Term::Ask { nxt, .. } | Term::Use { nxt, .. } => nxt.expand_ref_return(book, seen, globals_count), Term::Var { .. } | Term::Link { .. } | Term::Num { .. } | Term::Nat { .. } | Term::Str { .. } | Term::Oper { .. } | Term::Mat { .. } | Term::Swt { .. } | Term::Fold { .. } | Term::Bend { .. } | Term::Def { .. } | Term::Era | Term::Err => {} }) } fn expand_floated_combinators(&mut self, book: &Book) { maybe_grow(|| { if let Term::Ref { nam } = self { if nam.contains(super::float_combinators::NAME_SEP) { *self = book.defs.get(nam).unwrap().rule().body.clone(); } } for child in self.children_mut() { child.expand_floated_combinators(book); } }) } /// Read the term as an n-ary application. fn multi_arg_app(&mut self) -> (&mut Term, Vec<&mut Term>) { fn go<'a>(term: &'a mut Term, args: &mut Vec<&'a mut Term>) -> &'a mut Term { match term { Term::App { fun, arg, .. } => { args.push(arg); go(fun, args) } _ => term, } } let mut args = vec![]; let fun = go(self, &mut args); (fun, args) } } impl Term { /// Since expanded functions can contain unscoped variables, and /// unscoped variable names must be unique, we need to rename them /// to avoid conflicts. fn rename_unscoped(&mut self, unscoped_count: &mut usize, unscoped_map: &mut HashMap) { match self { Term::Let { pat, .. } | Term::Lam { pat, .. } => pat.rename_unscoped(unscoped_count, unscoped_map), Term::Link { nam } => rename_unscoped(nam, unscoped_count, unscoped_map), _ => { // Isn't an unscoped bind or use, do nothing, just recurse. } } for child in self.children_mut() { child.rename_unscoped(unscoped_count, unscoped_map); } } } impl Pattern { fn rename_unscoped(&mut self, unscoped_count: &mut usize, unscoped_map: &mut HashMap) { maybe_grow(|| { match self { Pattern::Chn(nam) => rename_unscoped(nam, unscoped_count, unscoped_map), _ => { // Pattern isn't an unscoped bind, just recurse. } } for child in self.children_mut() { child.rename_unscoped(unscoped_count, unscoped_map); } }) } } /// Generates a new name for an unscoped variable. fn rename_unscoped(nam: &mut Name, unscoped_count: &mut usize, unscoped_map: &mut HashMap) { if let Some(new_nam) = unscoped_map.get(nam) { *nam = new_nam.clone(); } else { let new_nam = Name::new(format!("{nam}%{}", unscoped_count)); unscoped_map.insert(nam.clone(), new_nam.clone()); *unscoped_count += 1; *nam = new_nam; } } ================================================ FILE: src/fun/transform/fix_match_defs.rs ================================================ use crate::{ diagnostics::Diagnostics, fun::{Adts, Constructors, Ctx, Pattern, Rule, Term}, }; impl Ctx<'_> { /// Makes every pattern matching definition have correct a left-hand side. /// /// Does not check exhaustiveness of rules and type mismatches. (Inter-ctr/type proprieties) pub fn fix_match_defs(&mut self) -> Result<(), Diagnostics> { for def in self.book.defs.values_mut() { let mut errs = vec![]; let def_arity = def.arity(); for rule in &mut def.rules { rule.fix_match_defs(def_arity, &self.book.ctrs, &self.book.adts, &mut errs); } for err in errs { self.info.add_function_error(err, def.name.clone(), def.source.clone()); } } self.info.fatal(()) } } impl Rule { fn fix_match_defs(&mut self, def_arity: usize, ctrs: &Constructors, adts: &Adts, errs: &mut Vec) { if self.arity() != def_arity { errs.push(format!( "Incorrect pattern matching rule arity. Expected {} args, found {}.", def_arity, self.arity() )); } for pat in &mut self.pats { pat.resolve_pat(ctrs); pat.check_good_ctr(ctrs, adts, errs); } self.body.fix_match_defs(ctrs, adts, errs); } } impl Term { fn fix_match_defs(&mut self, ctrs: &Constructors, adts: &Adts, errs: &mut Vec) { match self { Term::Def { def, nxt } => { let def_arity = def.arity(); for rule in &mut def.rules { rule.fix_match_defs(def_arity, ctrs, adts, errs); } nxt.fix_match_defs(ctrs, adts, errs); } _ => { for children in self.children_mut() { children.fix_match_defs(ctrs, adts, errs); } } } } } impl Pattern { /// If a var pattern actually refers to an ADT constructor, convert it into a constructor pattern. fn resolve_pat(&mut self, ctrs: &Constructors) { if let Pattern::Var(Some(nam)) = self { if ctrs.contains_key(nam) { *self = Pattern::Ctr(std::mem::take(nam), vec![]); } } for child in self.children_mut() { child.resolve_pat(ctrs); } } /// Check that ADT constructor pats are correct, meaning defined in a `data` and with correct arity. fn check_good_ctr(&self, ctrs: &Constructors, adts: &Adts, errs: &mut Vec) { if let Pattern::Ctr(nam, args) = self { if let Some(adt) = ctrs.get(nam) { let expected_arity = adts[adt].ctrs[nam].fields.len(); let found_arity = args.len(); if expected_arity != found_arity { errs.push(format!( "Incorrect arity for constructor '{}' of type '{}' in pattern matching rule. Expected {} fields, found {}", nam, adt, expected_arity, found_arity )); } } else { errs.push(format!("Unbound constructor '{nam}' in pattern matching rule.")); } } for child in self.children() { child.check_good_ctr(ctrs, adts, errs); } } } ================================================ FILE: src/fun/transform/fix_match_terms.rs ================================================ use crate::{ diagnostics::{Diagnostics, WarningType, ERR_INDENT_SIZE}, fun::{Adts, Constructors, CtrField, Ctx, MatchRule, Name, Num, Term}, maybe_grow, }; use std::collections::HashMap; enum FixMatchErr { AdtMismatch { expected: Name, found: Name, ctr: Name }, NonExhaustiveMatch { typ: Name, missing: Name }, IrrefutableMatch { var: Option }, UnreachableMatchArms { var: Option }, RedundantArm { ctr: Name }, } impl Ctx<'_> { /// Convert all match and switch expressions to a normalized form. /// * For matches, resolve the constructors and create the name of the field variables. /// * For switches, the resolution and name bind is already done during parsing. /// * Check for redundant arms and non-exhaustive matches. /// * Converts the initial bind to an alias on every arm, rebuilding the eliminated constructor /// * Since the bind is not needed anywhere else, it's erased from the term. /// /// Example: /// For the program /// ```hvm /// data MyList = (Cons h t) | Nil /// match x { /// Cons: (A x.h x.t) /// Nil: switch %arg = (Foo y) { 0: B; 1: C; _ %arg-2: D } /// } /// ``` /// The following AST transformations will be made: /// * The binds `x.h` and `x.t` will be generated and stored in the match term. /// * If it was missing one of the match cases, we'd get an error. /// * If it included one of the cases more than once (including wildcard patterns), we'd get a warning. /// ```hvm /// match * = x { /// Cons x.h x.t: use x = (Cons x.h x.t); (A x.h x.t) /// Nil: use x = Nil; /// switch * = (Foo y) { /// 0: use %arg = 0; B; /// 1: use %arg = 1; C; /// _: use %arg = (+ %arg-2 2); D /// } /// } /// ``` pub fn fix_match_terms(&mut self) -> Result<(), Diagnostics> { for def in self.book.defs.values_mut() { for rule in def.rules.iter_mut() { let errs = rule.body.fix_match_terms(&self.book.ctrs, &self.book.adts); for err in errs { match err { FixMatchErr::AdtMismatch { .. } | FixMatchErr::NonExhaustiveMatch { .. } => { self.info.add_function_error(err, def.name.clone(), def.source.clone()) } FixMatchErr::IrrefutableMatch { .. } => self.info.add_function_warning( err, WarningType::IrrefutableMatch, def.name.clone(), def.source.clone(), ), FixMatchErr::UnreachableMatchArms { .. } => self.info.add_function_warning( err, WarningType::UnreachableMatch, def.name.clone(), def.source.clone(), ), FixMatchErr::RedundantArm { .. } => self.info.add_function_warning( err, WarningType::RedundantMatch, def.name.clone(), def.source.clone(), ), } } } } self.info.fatal(()) } } impl Term { fn fix_match_terms(&mut self, ctrs: &Constructors, adts: &Adts) -> Vec { maybe_grow(|| { let mut errs = Vec::new(); for child in self.children_mut() { let mut e = child.fix_match_terms(ctrs, adts); errs.append(&mut e); } if matches!(self, Term::Mat { .. } | Term::Fold { .. }) { self.fix_match(&mut errs, ctrs, adts); } match self { Term::Def { def, nxt } => { for rule in def.rules.iter_mut() { errs.extend(rule.body.fix_match_terms(ctrs, adts)); } errs.extend(nxt.fix_match_terms(ctrs, adts)); } // Add a use term to each arm rebuilding the matched variable Term::Mat { arg: _, bnd, with_bnd: _, with_arg: _, arms } | Term::Fold { bnd, arg: _, with_bnd: _, with_arg: _, arms } => { for (ctr, fields, body) in arms { if let Some(ctr) = ctr { *body = Term::Use { nam: bnd.clone(), val: Box::new(Term::call( Term::Ref { nam: ctr.clone() }, fields.iter().flatten().cloned().map(|nam| Term::Var { nam }), )), nxt: Box::new(std::mem::take(body)), }; } } } Term::Swt { arg: _, bnd, with_bnd: _, with_arg: _, pred, arms } => { let n_nums = arms.len() - 1; for (i, arm) in arms.iter_mut().enumerate() { let orig = if i == n_nums { Term::add_num(Term::Var { nam: pred.clone().unwrap() }, Num::U24(i as u32)) } else { Term::Num { val: Num::U24(i as u32) } }; *arm = Term::Use { nam: bnd.clone(), val: Box::new(orig), nxt: Box::new(std::mem::take(arm)) }; } } _ => {} } // Remove the bound name match self { Term::Mat { bnd, .. } | Term::Swt { bnd, .. } | Term::Fold { bnd, .. } => *bnd = None, _ => {} } errs }) } fn fix_match(&mut self, errs: &mut Vec, ctrs: &Constructors, adts: &Adts) { let (Term::Mat { bnd, arg, with_bnd, with_arg, arms } | Term::Fold { bnd, arg, with_bnd, with_arg, arms }) = self else { unreachable!() }; let bnd = bnd.clone().unwrap(); // Normalize arms, making one arm for each constructor of the matched adt. if let Some(ctr_nam) = &arms[0].0 { if let Some(adt_nam) = ctrs.get(ctr_nam) { // First arm matches a constructor as expected, so we can normalize the arms. let adt_ctrs = &adts[adt_nam].ctrs; // Decide which constructor corresponds to which arm of the match. let mut bodies = fixed_match_arms(&bnd, arms, adt_nam, adt_ctrs.keys(), ctrs, adts, errs); // Build the match arms, with all constructors let mut new_rules = vec![]; for (ctr_nam, ctr) in adt_ctrs.iter() { let fields = ctr.fields.iter().map(|f| Some(match_field(&bnd, &f.nam))).collect::>(); let body = if let Some(Some(body)) = bodies.remove(ctr_nam) { body } else { errs.push(FixMatchErr::NonExhaustiveMatch { typ: adt_nam.clone(), missing: ctr_nam.clone() }); Term::Err }; new_rules.push((Some(ctr_nam.clone()), fields, body)); } *arms = new_rules; return; } } // First arm was not matching a constructor, irrefutable match, convert into a use term. errs.push(FixMatchErr::IrrefutableMatch { var: arms[0].0.clone() }); let match_var = arms[0].0.take(); let arg = std::mem::take(arg); let with_bnd = std::mem::take(with_bnd); let with_arg = std::mem::take(with_arg); // Replaces `self` by its irrefutable arm *self = std::mem::take(&mut arms[0].2); // `with` clause desugaring // Performs the same as `Term::linearize_match_with`. // Note that it only wraps the arm with function calls if `with_bnd` and `with_arg` aren't empty. *self = Term::rfold_lams(std::mem::take(self), with_bnd.into_iter()); *self = Term::call(std::mem::take(self), with_arg); if let Some(var) = match_var { *self = Term::Use { nam: Some(bnd.clone()), val: arg, nxt: Box::new(Term::Use { nam: Some(var), val: Box::new(Term::Var { nam: bnd }), nxt: Box::new(std::mem::take(self)), }), } } } } /// Given the rules of a match term, return the bodies that match /// each of the constructors of the matched ADT. /// /// If no rules match a certain constructor, return None in the map, /// indicating a non-exhaustive match. fn fixed_match_arms<'a>( bnd: &Name, rules: &mut Vec, adt_nam: &Name, adt_ctrs: impl Iterator, ctrs: &Constructors, adts: &Adts, errs: &mut Vec, ) -> HashMap<&'a Name, Option> { let mut bodies = HashMap::<&Name, Option>::from_iter(adt_ctrs.map(|ctr| (ctr, None))); for rule_idx in 0..rules.len() { // If Ctr arm, use the body of this rule for this constructor. if let Some(ctr_nam) = &rules[rule_idx].0 { if let Some(found_adt) = ctrs.get(ctr_nam) { if found_adt == adt_nam { let body = bodies.get_mut(ctr_nam).unwrap(); if body.is_none() { // Use this rule for this constructor *body = Some(rules[rule_idx].2.clone()); } else { errs.push(FixMatchErr::RedundantArm { ctr: ctr_nam.clone() }); } } else { errs.push(FixMatchErr::AdtMismatch { expected: adt_nam.clone(), found: found_adt.clone(), ctr: ctr_nam.clone(), }) } continue; } } // Otherwise, Var arm, use the body of this rule for all non-covered constructors. for (ctr, body) in bodies.iter_mut() { if body.is_none() { let mut new_body = rules[rule_idx].2.clone(); if let Some(var) = &rules[rule_idx].0 { new_body = Term::Use { nam: Some(var.clone()), val: Box::new(rebuild_ctr(bnd, ctr, &adts[adt_nam].ctrs[&**ctr].fields)), nxt: Box::new(new_body), }; } *body = Some(new_body); } } if rule_idx != rules.len() - 1 { errs.push(FixMatchErr::UnreachableMatchArms { var: rules[rule_idx].0.clone() }); rules.truncate(rule_idx + 1); } break; } bodies } fn match_field(arg: &Name, field: &Name) -> Name { Name::new(format!("{arg}.{field}")) } fn rebuild_ctr(arg: &Name, ctr: &Name, fields: &[CtrField]) -> Term { let ctr = Term::Ref { nam: ctr.clone() }; let fields = fields.iter().map(|f| Term::Var { nam: match_field(arg, &f.nam) }); Term::call(ctr, fields) } impl std::fmt::Display for FixMatchErr { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { FixMatchErr::AdtMismatch { expected, found, ctr } => write!( f, "Type mismatch in 'match' expression: Expected a constructor of type '{expected}', found '{ctr}' of type '{found}'" ), FixMatchErr::NonExhaustiveMatch { typ, missing } => { write!(f, "Non-exhaustive 'match' expression of type '{typ}'. Case '{missing}' not covered.") } FixMatchErr::IrrefutableMatch { var } => { writeln!( f, "Irrefutable 'match' expression. All cases after variable pattern '{}' will be ignored.", var.as_ref().unwrap_or(&Name::new("*")), )?; writeln!( f, "{:ERR_INDENT_SIZE$}Note that to use a 'match' expression, the matched constructors need to be defined in a 'data' definition.", "", )?; write!( f, "{:ERR_INDENT_SIZE$}If this is not a mistake, consider using a 'let' expression instead.", "" ) } FixMatchErr::UnreachableMatchArms { var } => write!( f, "Unreachable arms in 'match' expression. All cases after '{}' will be ignored.", var.as_ref().unwrap_or(&Name::new("*")) ), FixMatchErr::RedundantArm { ctr } => { write!(f, "Redundant arm in 'match' expression. Case '{ctr}' appears more than once.") } } } } ================================================ FILE: src/fun/transform/float_combinators.rs ================================================ use crate::{ fun::{Book, Definition, Name, Pattern, Rule, Source, Term}, maybe_grow, multi_iterator, }; use std::collections::{BTreeMap, HashSet}; pub const NAME_SEP: &str = "__C"; impl Book { /// Extracts combinator terms into new definitions. /// /// Precondition: Variables must have been sanitized. /// /// The floating algorithm follows these rules: /// For each child of the term: /// - Recursively float every grandchild term. /// - If the child is a combinator: /// * If the child is not "safe", extract it. /// * If the term is a combinator and it's "safe": /// - If the term is currently larger than `max_size`, extract the child. /// * Otherwise, always extract the child to a new definition. /// - If the child is not a combinator, we can't extract it since /// it would generate an invalid term. /// /// Terms are considered combinators if they have no free vars, /// no unmatched unscoped binds/vars and are not references (to /// avoid infinite recursion). /// /// See [`Term::is_safe`] for what is considered safe here. /// /// See [`Term::size`] for the measurement of size. /// It should more or less correspond to the compiled inet size. pub fn float_combinators(&mut self, max_size: usize) { let book = self.clone(); let mut ctx = FloatCombinatorsCtx::new(&book, max_size); for (def_name, def) in self.defs.iter_mut() { // Don't float combinators in the main entrypoint. // This avoids making programs unexpectedly too lazy, // returning just a reference without executing anything. if let Some(main) = self.entrypoint.as_ref() { if def_name == main { continue; } } let source = def.source.clone(); let check = def.check; let body = &mut def.rule_mut().body; ctx.reset(); ctx.def_size = body.size(); body.float_combinators(&mut ctx, def_name, source, check); } self.defs.extend(ctx.combinators.into_iter().map(|(nam, (_, def))| (nam, def))); } } struct FloatCombinatorsCtx<'b> { pub combinators: BTreeMap, pub name_gen: usize, pub seen: HashSet, pub book: &'b Book, pub max_size: usize, pub def_size: usize, } impl<'b> FloatCombinatorsCtx<'b> { fn new(book: &'b Book, max_size: usize) -> Self { Self { combinators: Default::default(), name_gen: 0, seen: Default::default(), book, max_size, def_size: 0, } } fn reset(&mut self) { self.def_size = 0; self.name_gen = 0; self.seen = Default::default(); } } impl Term { fn float_combinators( &mut self, ctx: &mut FloatCombinatorsCtx, def_name: &Name, source: Source, check: bool, ) { maybe_grow(|| { // Recursively float the grandchildren terms. for child in self.float_children_mut() { child.float_combinators(ctx, def_name, source.clone(), check); } let mut size = self.size(); let is_combinator = self.is_combinator(); // Float unsafe children and children that make the term too big. for child in self.float_children_mut() { let child_is_safe = child.is_safe(ctx); let child_size = child.size(); let extract_for_size = if is_combinator { size > ctx.max_size } else { ctx.def_size > ctx.max_size }; if child.is_combinator() && child_size > 0 && (!child_is_safe || extract_for_size) { ctx.def_size -= child_size; size -= child_size; child.float(ctx, def_name, source.clone(), check, child_is_safe); } } }) } /// Inserts a new definition for the given term in the combinators map. fn float( &mut self, ctx: &mut FloatCombinatorsCtx, def_name: &Name, source: Source, check: bool, is_safe: bool, ) { let comb_name = Name::new(format!("{}{}{}", def_name, NAME_SEP, ctx.name_gen)); ctx.name_gen += 1; let comb_ref = Term::Ref { nam: comb_name.clone() }; let extracted_term = std::mem::replace(self, comb_ref); let rules = vec![Rule { body: extracted_term, pats: Vec::new() }]; let rule = Definition::new_gen(comb_name.clone(), rules, source, check); ctx.combinators.insert(comb_name, (is_safe, rule)); } } impl Term { /// A term can be considered safe if it is: /// - A Number or an Eraser. /// - A Tuple or Superposition where all elements are safe. /// - An application or numeric operation where all arguments are safe. /// - A safe Lambda, e.g. a nullary constructor or a lambda with safe body. /// - A Reference with a safe body. /// /// A reference to a recursive definition (or mutually recursive) is not safe. fn is_safe(&self, ctx: &mut FloatCombinatorsCtx) -> bool { maybe_grow(|| match self { Term::Num { .. } | Term::Era | Term::Err | Term::Fan { .. } | Term::App { .. } | Term::Oper { .. } | Term::Swt { .. } => self.children().all(|c| c.is_safe(ctx)), Term::Lam { .. } => self.is_safe_lambda(ctx), Term::Ref { nam } => { // Constructors are safe if ctx.book.ctrs.contains_key(nam) { return true; } // If recursive, not safe if ctx.seen.contains(nam) { return false; } ctx.seen.insert(nam.clone()); // Check if the function it's referring to is safe let safe = if let Some(def) = ctx.book.defs.get(nam) { def.rule().body.is_safe(ctx) } else if let Some((safe, _)) = ctx.combinators.get(nam) { *safe } else { false }; ctx.seen.remove(nam); safe } // TODO: Variables can be safe depending on how they're used // For example, in a well-typed numop they're safe. _ => false, }) } /// Checks if the term is a lambda sequence with a safe body. /// If the body is a variable bound in the lambdas, it's a nullary constructor. /// If the body is a reference, it's in inactive position, so always safe. fn is_safe_lambda(&self, ctx: &mut FloatCombinatorsCtx) -> bool { let mut current = self; let mut scope = Vec::new(); while let Term::Lam { pat, bod, .. } = current { scope.extend(pat.binds().filter_map(|x| x.as_ref())); current = bod; } match current { Term::Var { nam } if scope.contains(&nam) => true, Term::Ref { .. } => true, term => term.is_safe(ctx), } } pub fn has_unscoped_diff(&self) -> bool { let (declared, used) = self.unscoped_vars(); declared.difference(&used).count() != 0 || used.difference(&declared).count() != 0 } fn is_combinator(&self) -> bool { self.free_vars().is_empty() && !self.has_unscoped_diff() && !matches!(self, Term::Ref { .. }) } fn base_size(&self) -> usize { match self { Term::Let { pat, .. } => pat.size(), Term::Fan { els, .. } => els.len() - 1, Term::Mat { arms, .. } => arms.len(), Term::Swt { arms, .. } => 2 * (arms.len() - 1), Term::Lam { .. } => 1, Term::App { .. } => 1, Term::Oper { .. } => 1, Term::Var { .. } => 0, Term::Link { .. } => 0, Term::Use { .. } => 0, Term::Num { .. } => 0, Term::Ref { .. } => 0, Term::Era => 0, Term::Bend { .. } | Term::Fold { .. } | Term::Nat { .. } | Term::Str { .. } | Term::List { .. } | Term::With { .. } | Term::Ask { .. } | Term::Open { .. } | Term::Def { .. } | Term::Err => unreachable!(), } } fn size(&self) -> usize { maybe_grow(|| { let children_size: usize = self.children().map(|c| c.size()).sum(); self.base_size() + children_size }) } pub fn float_children_mut(&mut self) -> impl Iterator { multi_iterator!(FloatIter { Zero, Two, Vec, Mat, App, Swt }); match self { Term::App { .. } => { let mut next = Some(self); FloatIter::App(std::iter::from_fn(move || { let cur = next.take(); if let Some(Term::App { fun, arg, .. }) = cur { next = Some(&mut *fun); Some(&mut **arg) } else { cur } })) } Term::Mat { arg, bnd: _, with_bnd: _, with_arg, arms } => FloatIter::Mat( [arg.as_mut()].into_iter().chain(with_arg.iter_mut()).chain(arms.iter_mut().map(|r| &mut r.2)), ), Term::Swt { arg, bnd: _, with_bnd: _, with_arg, pred: _, arms } => { FloatIter::Swt([arg.as_mut()].into_iter().chain(with_arg.iter_mut()).chain(arms.iter_mut())) } Term::Fan { els, .. } | Term::List { els } => FloatIter::Vec(els), Term::Let { val: fst, nxt: snd, .. } | Term::Use { val: fst, nxt: snd, .. } | Term::Oper { fst, snd, .. } => FloatIter::Two([fst.as_mut(), snd.as_mut()]), Term::Lam { bod, .. } => bod.float_children_mut(), Term::Var { .. } | Term::Link { .. } | Term::Num { .. } | Term::Nat { .. } | Term::Str { .. } | Term::Ref { .. } | Term::Era | Term::Err => FloatIter::Zero([]), Term::With { .. } | Term::Ask { .. } | Term::Bend { .. } | Term::Fold { .. } | Term::Open { .. } | Term::Def { .. } => { unreachable!() } } } } impl Pattern { fn size(&self) -> usize { match self { Pattern::Var(_) => 0, Pattern::Chn(_) => 0, Pattern::Fan(_, _, pats) => pats.len() - 1 + pats.iter().map(|p| p.size()).sum::(), Pattern::Num(_) | Pattern::Lst(_) | Pattern::Str(_) | Pattern::Ctr(_, _) => unreachable!(), } } } ================================================ FILE: src/fun/transform/lift_local_defs.rs ================================================ use std::collections::BTreeSet; use indexmap::IndexMap; use crate::{ fun::{Book, Definition, Name, Pattern, Rule, Term}, maybe_grow, }; impl Book { pub fn lift_local_defs(&mut self) { let mut defs = IndexMap::new(); for (name, def) in self.defs.iter_mut() { let mut gen = 0; for rule in def.rules.iter_mut() { rule.body.lift_local_defs(name, def.check, &mut defs, &mut gen); } } self.defs.extend(defs); } } impl Rule { pub fn binds(&self) -> impl DoubleEndedIterator> + Clone { self.pats.iter().flat_map(Pattern::binds) } } impl Term { pub fn lift_local_defs( &mut self, parent: &Name, check: bool, defs: &mut IndexMap, gen: &mut usize, ) { maybe_grow(|| match self { Term::Def { def, nxt } => { let local_name = Name::new(format!("{}__local_{}_{}", parent, gen, def.name)); for rule in def.rules.iter_mut() { rule.body.lift_local_defs(&local_name, check, defs, gen); } nxt.lift_local_defs(parent, check, defs, gen); *gen += 1; let inner_defs = defs.keys().filter(|name| name.starts_with(local_name.as_ref())).cloned().collect::>(); let (r#use, fvs, mut rules) = gen_use(inner_defs, &local_name, &def.name, nxt, std::mem::take(&mut def.rules)); let source = std::mem::take(&mut def.source); *self = r#use; apply_closure(&mut rules, &fvs); let new_def = Definition::new_gen(local_name.clone(), rules, source, check); defs.insert(local_name.clone(), new_def); } _ => { for child in self.children_mut() { child.lift_local_defs(parent, check, defs, gen); } } }) } } fn gen_use( inner_defs: BTreeSet, local_name: &Name, nam: &Name, nxt: &mut Box, mut rules: Vec, ) -> (Term, BTreeSet, Vec) { let mut fvs = BTreeSet::::new(); for rule in rules.iter() { fvs.extend(rule.body.free_vars().into_keys().collect::>()); } fvs.retain(|fv| !inner_defs.contains(fv)); for rule in rules.iter() { for bind in rule.binds().flatten() { fvs.remove(bind); } } fvs.remove(nam); let call = Term::call( Term::Ref { nam: local_name.clone() }, fvs.iter().cloned().map(|nam| Term::Var { nam }).collect::>(), ); for rule in rules.iter_mut() { let slf = std::mem::take(&mut rule.body); rule.body = Term::Use { nam: Some(nam.clone()), val: Box::new(call.clone()), nxt: Box::new(slf) }; } let r#use = Term::Use { nam: Some(nam.clone()), val: Box::new(call.clone()), nxt: std::mem::take(nxt) }; (r#use, fvs, rules) } fn apply_closure(rules: &mut [Rule], fvs: &BTreeSet) { for rule in rules.iter_mut() { let captured = fvs.iter().cloned().map(Some).collect::>(); rule.body = Term::rfold_lams(std::mem::take(&mut rule.body), captured.into_iter()); } } ================================================ FILE: src/fun/transform/linearize_matches.rs ================================================ use crate::{ fun::{Book, Name, Pattern, Term}, maybe_grow, }; use std::collections::{BTreeSet, HashMap, HashSet, VecDeque}; /* Linearize preceding binds */ impl Book { /// Linearization of binds preceding match/switch terms, up to the /// first bind used in either the scrutinee or the bind. /// /// Example: /// ```hvm /// @a @b @c let d = (b c); switch a { /// 0: (A b c d) /// _: (B a-1 b c d) /// } /// // Since `b`, `c` and `d` would be eta-reducible if linearized, /// // they get pushed inside the match. /// @a switch a { /// 0: @b @c let d = (b c); (A b c d) /// _: @b @c let d = (b c); (B a-1 b c d) /// } /// ``` pub fn linearize_match_binds(&mut self) { for def in self.defs.values_mut() { for rule in def.rules.iter_mut() { rule.body.linearize_match_binds(); } } } } impl Term { /// Linearize any binds preceding a match/switch term, up to the /// first bind used in either the scrutinee or the bind. pub fn linearize_match_binds(&mut self) { self.linearize_match_binds_go(vec![]); } fn linearize_match_binds_go(&mut self, mut bind_terms: Vec) { maybe_grow(|| match self { // Binding terms // Extract them in case they are preceding a match. Term::Lam { pat, bod, .. } if !pat.has_unscoped() => { let bod = std::mem::take(bod.as_mut()); let term = std::mem::replace(self, bod); bind_terms.push(term); self.linearize_match_binds_go(bind_terms); } Term::Let { val, nxt, .. } | Term::Use { val, nxt, .. } => { val.linearize_match_binds_go(vec![]); if val.has_unscoped() { // Terms with unscoped can't be linearized since their names must be unique. nxt.linearize_match_binds_go(vec![]); self.wrap_with_bind_terms(bind_terms); } else { let nxt = std::mem::take(nxt.as_mut()); let term = std::mem::replace(self, nxt); bind_terms.push(term); self.linearize_match_binds_go(bind_terms); } } // Matching terms Term::Mat { .. } | Term::Swt { .. } => { self.linearize_binds_single_match(bind_terms); } // Others // Not a match preceded by binds, so put the extracted terms back. term => { for child in term.children_mut() { child.linearize_match_binds_go(vec![]); } // Recover the extracted terms term.wrap_with_bind_terms(bind_terms); } }) } fn linearize_binds_single_match(&mut self, mut bind_terms: Vec) { let (used_vars, with_bnd, with_arg, arms) = match self { Term::Mat { arg, bnd: _, with_bnd, with_arg, arms } => { let vars = arg.free_vars().into_keys().collect::>(); let arms = arms.iter_mut().map(|arm| &mut arm.2).collect::>(); (vars, with_bnd, with_arg, arms) } Term::Swt { arg, bnd: _, with_bnd, with_arg, pred: _, arms } => { let vars = arg.free_vars().into_keys().collect::>(); let arms = arms.iter_mut().collect(); (vars, with_bnd, with_arg, arms) } _ => unreachable!(), }; // Add 'with' args as lets that can be moved for (bnd, arg) in with_bnd.iter().zip(with_arg.iter()) { let term = Term::Let { pat: Box::new(Pattern::Var(bnd.clone())), val: Box::new(arg.clone()), nxt: Box::new(Term::Err), }; bind_terms.push(term) } let (mut non_linearized, linearized) = fixed_and_linearized_terms(used_vars, bind_terms); // Add the linearized terms to the arms and recurse for arm in arms { arm.wrap_with_bind_terms(linearized.clone()); arm.linearize_match_binds_go(vec![]); } // Remove the linearized binds from the with clause let linearized_binds = linearized .iter() .flat_map(|t| match t { Term::Lam { pat, .. } | Term::Let { pat, .. } => pat.binds().flatten().cloned().collect::>(), Term::Use { nam, .. } => { if let Some(nam) = nam { vec![nam.clone()] } else { vec![] } } _ => unreachable!(), }) .collect::>(); update_with_clause(with_bnd, with_arg, &linearized_binds); // Remove the non-linearized 'with' binds from the terms that need // to be added back (since we didn't move them). non_linearized.retain(|term| { if let Term::Let { pat, .. } = term { if let Pattern::Var(bnd) = pat.as_ref() { if with_bnd.contains(bnd) { return false; } } } true }); // Add the non-linearized terms back to before the match self.wrap_with_bind_terms(non_linearized); } /// Given a term `self` and a sequence of `bind_terms`, wrap `self` with those binds. /// /// Example: /// ```hvm /// self = X /// match_terms = [λb *, let c = (a b); *, λd *] /// ``` /// /// becomes /// /// ```hvm /// self = λb let c = (a b); λd X /// ``` fn wrap_with_bind_terms( &mut self, bind_terms: impl IntoIterator>, ) { *self = bind_terms.into_iter().rfold(std::mem::take(self), |acc, mut term| { match &mut term { Term::Lam { bod: nxt, .. } | Term::Let { nxt, .. } | Term::Use { nxt, .. } => { *nxt.as_mut() = acc; } _ => unreachable!(), } term }); } } /// Separates the bind terms surround the match in two partitions, /// one to be linearized, one to stay where they where. /// /// We try to move down any binds that would become eta-reducible with linearization /// and that will not introduce extra duplications. /// /// This requires the bind to follow some rules: /// * Can only depend on binds that will be moved /// * Can't come before any bind that will not be moved. /// * Must be a scoped bind. /// /// Examples: /// /// ```hvm /// @a @b @c switch b { 0: c; _: (c b-1) } /// // Will linearize `c` but not `a` since it comes before a lambda that can't be moved /// // Becomes /// @a @b switch b { 0: @c c; _: @c (c b-1) } /// ``` /// /// ```hvm /// @a let b = a; @c let e = b; let d = c; switch a { 0: X; _: Y } /// // Will not linearize `let b = a` since it would duplicate `a` /// // Will linearize `c` since it's a lambda that is not depended on by the argument /// // Will not linearize `let e = b` since it would duplicate `b` /// // Will linearize `let d = c` since it depends only on variables that will be moved /// // and is not depended on by the argument /// ``` fn fixed_and_linearized_terms(used_in_arg: HashSet, bind_terms: Vec) -> (Vec, Vec) { let fixed_binds = binds_fixed_by_dependency(used_in_arg, &bind_terms); let mut fixed = VecDeque::new(); let mut linearized = VecDeque::new(); let mut stop = false; for term in bind_terms.into_iter().rev() { let to_linearize = match &term { Term::Use { nam, .. } => nam.as_ref().map_or(true, |nam| !fixed_binds.contains(nam)), Term::Let { pat, .. } => pat.binds().flatten().all(|nam| !fixed_binds.contains(nam)), Term::Lam { pat, .. } => pat.binds().flatten().all(|nam| !fixed_binds.contains(nam)), _ => unreachable!(), }; let to_linearize = to_linearize && !stop; if to_linearize { linearized.push_front(term); } else { if matches!(term, Term::Lam { .. }) { stop = true; } fixed.push_front(term); } } (fixed.into_iter().collect(), linearized.into_iter().collect()) } /// Get which binds are fixed because they are in the dependency graph /// of a free var or of a var used in the match arg. fn binds_fixed_by_dependency(used_in_arg: HashSet, bind_terms: &[Term]) -> HashSet { let mut fixed_binds = used_in_arg; // Find the use dependencies of each bind let mut binds = vec![]; let mut dependency_digraph = HashMap::new(); for term in bind_terms { // Gather what are the binds of this term and what vars it is directly using let (term_binds, term_uses) = match term { Term::Lam { pat, .. } => { let binds = pat.binds().flatten().cloned().collect::>(); (binds, vec![]) } Term::Let { pat, val, .. } => { let binds = pat.binds().flatten().cloned().collect::>(); let uses = val.free_vars().into_keys().collect(); (binds, uses) } Term::Use { nam, val, .. } => { let binds = if let Some(nam) = nam { vec![nam.clone()] } else { vec![] }; let uses = val.free_vars().into_keys().collect(); (binds, uses) } _ => unreachable!(), }; for bind in term_binds { dependency_digraph.insert(bind.clone(), term_uses.clone()); binds.push(bind); } } // Mark binds that depend on free vars as fixed for (bind, deps) in dependency_digraph.iter() { if deps.iter().any(|dep| !binds.contains(dep)) { fixed_binds.insert(bind.clone()); } } // Convert to undirected graph let mut dependency_graph: HashMap> = HashMap::from_iter(binds.iter().map(|k| (k.clone(), HashSet::new()))); for (bind, deps) in dependency_digraph { for dep in deps { if !binds.contains(&dep) { dependency_graph.insert(dep.clone(), HashSet::new()); } dependency_graph.get_mut(&dep).unwrap().insert(bind.clone()); dependency_graph.get_mut(&bind).unwrap().insert(dep); } } // Find which binds are connected to the vars used in the match arg or to free vars. let mut used_component = HashSet::new(); let mut visited = HashSet::new(); let mut to_visit = fixed_binds.iter().collect::>(); while let Some(node) = to_visit.pop() { if visited.contains(node) { continue; } used_component.insert(node.clone()); visited.insert(node); // Add these dependencies to be checked (if it's not a free var in the match arg) if let Some(deps) = dependency_graph.get(node) { to_visit.extend(deps); } } // Mark lambdas that come before a fixed lambda as also fixed let mut fixed_start = false; let mut fixed_lams = HashSet::new(); for term in bind_terms.iter().rev() { if let Term::Lam { pat, .. } = term { if pat.binds().flatten().any(|p| used_component.contains(p)) { fixed_start = true; } if fixed_start { for bind in pat.binds().flatten() { fixed_lams.insert(bind.clone()); } } } } let mut fixed_binds = used_component; // Mark binds that depend on fixed lambdas as also fixed. let mut visited = HashSet::new(); let mut to_visit = fixed_lams.iter().collect::>(); while let Some(node) = to_visit.pop() { if visited.contains(node) { continue; } fixed_binds.insert(node.clone()); visited.insert(node); // Add these dependencies to be checked (if it's not a free var in the match arg) if let Some(deps) = dependency_graph.get(node) { to_visit.extend(deps); } } fixed_binds } fn update_with_clause( with_bnd: &mut Vec>, with_arg: &mut Vec, vars_to_lift: &BTreeSet, ) { let mut to_remove = Vec::new(); for i in 0..with_bnd.len() { if let Some(with_bnd) = &with_bnd[i] { if vars_to_lift.contains(with_bnd) { to_remove.push(i); } } } for (removed, to_remove) in to_remove.into_iter().enumerate() { with_bnd.remove(to_remove - removed); with_arg.remove(to_remove - removed); } } /* Linearize all used vars */ impl Book { /// Linearizes all variables used in a matches' arms. pub fn linearize_matches(&mut self) { for def in self.defs.values_mut() { for rule in def.rules.iter_mut() { rule.body.linearize_matches(); } } } } impl Term { fn linearize_matches(&mut self) { maybe_grow(|| { for child in self.children_mut() { child.linearize_matches(); } if matches!(self, Term::Mat { .. } | Term::Swt { .. }) { lift_match_vars(self); } }) } } /// Converts free vars inside the match arms into lambdas with /// applications around the match to pass them the external value. /// /// Makes the rules extractable and linear (no need for dups even /// when a variable is used in multiple rules). /// /// Obs: This does not modify unscoped variables. pub fn lift_match_vars(match_term: &mut Term) -> &mut Term { // Collect match arms with binds let (with_bnd, with_arg, arms) = match match_term { Term::Mat { arg: _, bnd: _, with_bnd, with_arg, arms: rules } => { let args = rules.iter().map(|(_, binds, body)| (binds.iter().flatten().cloned().collect(), body)).collect(); (with_bnd.clone(), with_arg.clone(), args) } Term::Swt { arg: _, bnd: _, with_bnd, with_arg, pred, arms } => { let (succ, nums) = arms.split_last_mut().unwrap(); let mut arms = nums.iter().map(|body| (vec![], body)).collect::>(); arms.push((vec![pred.clone().unwrap()], succ)); (with_bnd.clone(), with_arg.clone(), arms) } _ => unreachable!(), }; // Collect all free vars in the match arms let mut free_vars = Vec::>::new(); for (binds, body) in arms { let mut arm_free_vars = body.free_vars(); for bind in binds { arm_free_vars.shift_remove(&bind); } free_vars.push(arm_free_vars.into_keys().collect()); } // Collect the vars to lift // We need consistent iteration order. let vars_to_lift: BTreeSet = free_vars.into_iter().flatten().collect(); // Add lambdas to the arms match match_term { Term::Mat { arg: _, bnd: _, with_bnd, with_arg, arms } => { update_with_clause(with_bnd, with_arg, &vars_to_lift); for arm in arms { let old_body = std::mem::take(&mut arm.2); arm.2 = Term::rfold_lams(old_body, vars_to_lift.iter().cloned().map(Some)); } } Term::Swt { arg: _, bnd: _, with_bnd, with_arg, pred: _, arms } => { update_with_clause(with_bnd, with_arg, &vars_to_lift); for arm in arms { let old_body = std::mem::take(arm); *arm = Term::rfold_lams(old_body, vars_to_lift.iter().cloned().map(Some)); } } _ => unreachable!(), } // Add apps to the match let args = vars_to_lift .into_iter() .map(|nam| { if let Some(idx) = with_bnd.iter().position(|x| x == &nam) { with_arg[idx].clone() } else { Term::Var { nam } } }) .collect::>(); let term = Term::call(std::mem::take(match_term), args); *match_term = term; get_match_reference(match_term) } /// Get a reference to the match again /// It returns a reference and not an owned value because we want /// to keep the new surrounding Apps but still modify the match further. fn get_match_reference(mut match_term: &mut Term) -> &mut Term { loop { match match_term { Term::App { tag: _, fun, arg: _ } => match_term = fun.as_mut(), Term::Swt { .. } | Term::Mat { .. } => return match_term, _ => unreachable!(), } } } /* Linearize `with` vars */ impl Book { /// Linearizes all variables specified in the `with` clauses of match terms. pub fn linearize_match_with(&mut self) { for def in self.defs.values_mut() { for rule in def.rules.iter_mut() { rule.body.linearize_match_with(); } } } } impl Term { fn linearize_match_with(&mut self) { maybe_grow(|| { for child in self.children_mut() { child.linearize_match_with(); } }); match self { Term::Mat { arg: _, bnd: _, with_bnd, with_arg, arms } => { for rule in arms { rule.2 = Term::rfold_lams(std::mem::take(&mut rule.2), with_bnd.clone().into_iter()); } *with_bnd = vec![]; let call_args = std::mem::take(with_arg).into_iter(); *self = Term::call(std::mem::take(self), call_args); } Term::Swt { arg: _, bnd: _, with_bnd, with_arg, pred: _, arms } => { for rule in arms { *rule = Term::rfold_lams(std::mem::take(rule), with_bnd.clone().into_iter()); } *with_bnd = vec![]; let call_args = std::mem::take(with_arg).into_iter(); *self = Term::call(std::mem::take(self), call_args); } _ => {} } } } ================================================ FILE: src/fun/transform/linearize_vars.rs ================================================ use crate::{ fun::{Book, FanKind, Name, Pattern, Tag, Term}, maybe_grow, multi_iterator, }; use std::collections::HashMap; /// Erases variables that weren't used, dups the ones that were used more than once. /// Substitutes lets into their variable use. /// In details: /// For all var declarations: /// If they're used 0 times: erase the declaration /// If they're used 1 time: leave them as-is /// If they're used more times: insert dups to make var use affine /// For all let vars: /// If they're used 0 times: Discard the let /// If they're used 1 time: substitute the body in the var use /// If they're use more times: add dups for all the uses, put the let body at the root dup. /// Precondition: All variables are bound and have unique names within each definition. impl Book { pub fn linearize_vars(&mut self) { for def in self.defs.values_mut() { def.rule_mut().body.linearize_vars(); } } } impl Term { pub fn linearize_vars(&mut self) { term_to_linear(self, &mut HashMap::new()); } } fn term_to_linear(term: &mut Term, var_uses: &mut HashMap) { maybe_grow(|| { if let Term::Let { pat, val, nxt } = term { if let Pattern::Var(Some(nam)) = pat.as_ref() { // TODO: This is swapping the order of how the bindings are // used, since it's not following the usual AST order (first // val, then nxt). Doesn't change behaviour, but looks strange. term_to_linear(nxt, var_uses); let uses = get_var_uses(Some(nam), var_uses); term_to_linear(val, var_uses); match uses { 0 => { let Term::Let { pat, .. } = term else { unreachable!() }; **pat = Pattern::Var(None); } 1 => { nxt.subst(nam, val.as_ref()); *term = std::mem::take(nxt.as_mut()); } _ => { let new_pat = duplicate_pat(nam, uses); let Term::Let { pat, .. } = term else { unreachable!() }; *pat = new_pat; } } return; } } if let Term::Var { nam } = term { let instantiated_count = var_uses.entry(nam.clone()).or_default(); *instantiated_count += 1; *nam = dup_name(nam, *instantiated_count); return; } for (child, binds) in term.children_mut_with_binds_mut() { term_to_linear(child, var_uses); for bind in binds { let uses = get_var_uses(bind.as_ref(), var_uses); match uses { // Erase binding 0 => *bind = None, // Keep as-is 1 => (), // Duplicate binding uses => { debug_assert!(uses > 1); let nam = bind.as_ref().unwrap(); *child = Term::Let { pat: duplicate_pat(nam, uses), val: Box::new(Term::Var { nam: nam.clone() }), nxt: Box::new(std::mem::take(child)), } } } } } }) } fn get_var_uses(nam: Option<&Name>, var_uses: &HashMap) -> u64 { nam.and_then(|nam| var_uses.get(nam).copied()).unwrap_or_default() } fn duplicate_pat(nam: &Name, uses: u64) -> Box { Box::new(Pattern::Fan( FanKind::Dup, Tag::Auto, (1..uses + 1).map(|i| Pattern::Var(Some(dup_name(nam, i)))).collect(), )) } fn dup_name(nam: &Name, uses: u64) -> Name { if uses == 1 { nam.clone() } else { Name::new(format!("{nam}_{uses}")) } } impl Term { /// Because multiple children can share the same binds, this function is very restricted. /// Should only be called after desugaring bends/folds/matches/switches. pub fn children_mut_with_binds_mut( &mut self, ) -> impl DoubleEndedIterator>)> { multi_iterator!(ChildrenIter { Zero, One, Two, Vec, Swt }); multi_iterator!(BindsIter { Zero, One, Pat }); match self { Term::Swt { arg, bnd, with_bnd, with_arg, pred, arms } => { debug_assert!(bnd.is_none()); debug_assert!(with_bnd.is_empty()); debug_assert!(with_arg.is_empty()); debug_assert!(pred.is_none()); ChildrenIter::Swt( [(arg.as_mut(), BindsIter::Zero([]))] .into_iter() .chain(arms.iter_mut().map(|x| (x, BindsIter::Zero([])))), ) } Term::Fan { els, .. } | Term::List { els } => { ChildrenIter::Vec(els.iter_mut().map(|el| (el, BindsIter::Zero([])))) } Term::Use { nam, val, nxt } => { ChildrenIter::Two([(val.as_mut(), BindsIter::Zero([])), (nxt.as_mut(), BindsIter::One([nam]))]) } Term::Let { pat, val, nxt, .. } | Term::Ask { pat, val, nxt, .. } => ChildrenIter::Two([ (val.as_mut(), BindsIter::Zero([])), (nxt.as_mut(), BindsIter::Pat(pat.binds_mut())), ]), Term::App { fun: fst, arg: snd, .. } | Term::Oper { fst, snd, .. } => { ChildrenIter::Two([(fst.as_mut(), BindsIter::Zero([])), (snd.as_mut(), BindsIter::Zero([]))]) } Term::Lam { pat, bod, .. } => ChildrenIter::One([(bod.as_mut(), BindsIter::Pat(pat.binds_mut()))]), Term::With { bod, .. } => ChildrenIter::One([(bod.as_mut(), BindsIter::Zero([]))]), Term::Var { .. } | Term::Link { .. } | Term::Num { .. } | Term::Nat { .. } | Term::Str { .. } | Term::Ref { .. } | Term::Era | Term::Err => ChildrenIter::Zero([]), Term::Mat { .. } => unreachable!("'match' should be removed in earlier pass"), Term::Fold { .. } => unreachable!("'fold' should be removed in earlier pass"), Term::Bend { .. } => unreachable!("'bend' should be removed in earlier pass"), Term::Open { .. } => unreachable!("'open' should be removed in earlier pass"), Term::Def { .. } => unreachable!("'def' should be removed in earlier pass"), } } } ================================================ FILE: src/fun/transform/mod.rs ================================================ pub mod apply_args; pub mod definition_merge; pub mod definition_pruning; pub mod desugar_bend; pub mod desugar_fold; pub mod desugar_match_defs; pub mod desugar_open; pub mod desugar_use; pub mod desugar_with_blocks; pub mod encode_adts; pub mod encode_match_terms; pub mod expand_generated; pub mod expand_main; pub mod fix_match_defs; pub mod fix_match_terms; pub mod float_combinators; pub mod lift_local_defs; pub mod linearize_matches; pub mod linearize_vars; pub mod resolve_refs; pub mod resolve_type_ctrs; pub mod resugar_list; pub mod resugar_string; pub mod unique_names; ================================================ FILE: src/fun/transform/resolve_refs.rs ================================================ use crate::{ diagnostics::Diagnostics, fun::{Ctx, Name, Pattern, Term}, maybe_grow, }; use std::collections::{HashMap, HashSet}; #[derive(Debug, Clone)] pub struct ReferencedMainErr; impl Ctx<'_> { /// Decides if names inside a term belong to a Var or to a Ref. /// Converts `Term::Var(nam)` into `Term::Ref(nam)` when the name /// refers to a function definition and there is no variable in /// scope shadowing that definition. /// /// Precondition: Refs are encoded as vars, Constructors are resolved. /// /// Postcondition: Refs are encoded as refs, with the correct def id. pub fn resolve_refs(&mut self) -> Result<(), Diagnostics> { let def_names = self.book.defs.keys().cloned().chain(self.book.hvm_defs.keys().cloned()).collect::>(); for (def_name, def) in &mut self.book.defs { for rule in def.rules.iter_mut() { let mut scope = HashMap::new(); for name in rule.pats.iter().flat_map(Pattern::binds) { push_scope(name.as_ref(), &mut scope); } let res = rule.body.resolve_refs(&def_names, self.book.entrypoint.as_ref(), &mut scope, &mut self.info); self.info.take_rule_err(res, def_name.clone()); } } self.info.fatal(()) } } impl Term { pub fn resolve_refs<'a>( &'a mut self, def_names: &HashSet, main: Option<&Name>, scope: &mut HashMap<&'a Name, usize>, info: &mut Diagnostics, ) -> Result<(), String> { maybe_grow(move || { match self { Term::Var { nam } => { if is_var_in_scope(nam, scope) { // If the variable is actually a reference to main, don't swap and return an error. if let Some(main) = main { if nam == main { return Err("Main definition can't be referenced inside the program.".to_string()); } } // If the variable is actually a reference to a function, swap the term. if def_names.contains(nam) { *self = Term::r#ref(nam); } } } Term::Def { def, nxt } => { for rule in def.rules.iter_mut() { let mut scope = HashMap::new(); for name in rule.pats.iter().flat_map(Pattern::binds) { push_scope(name.as_ref(), &mut scope); } let res = rule.body.resolve_refs(def_names, main, &mut scope, info); info.take_rule_err(res, def.name.clone()); } nxt.resolve_refs(def_names, main, scope, info)?; } _ => { for (child, binds) in self.children_mut_with_binds() { for bind in binds.clone() { push_scope(bind.as_ref(), scope); } child.resolve_refs(def_names, main, scope, info)?; for bind in binds.rev() { pop_scope(bind.as_ref(), scope); } } } } Ok(()) }) } } fn push_scope<'a>(name: Option<&'a Name>, scope: &mut HashMap<&'a Name, usize>) { if let Some(name) = name { let var_scope = scope.entry(name).or_default(); *var_scope += 1; } } fn pop_scope<'a>(name: Option<&'a Name>, scope: &mut HashMap<&'a Name, usize>) { if let Some(name) = name { let var_scope = scope.entry(name).or_default(); *var_scope -= 1; } } fn is_var_in_scope<'a>(name: &'a Name, scope: &HashMap<&'a Name, usize>) -> bool { match scope.get(name) { Some(entry) => *entry == 0, None => true, } } ================================================ FILE: src/fun/transform/resolve_type_ctrs.rs ================================================ use crate::{ diagnostics::Diagnostics, fun::{Adts, Ctx, Type}, maybe_grow, }; impl Ctx<'_> { /// Resolves type constructors in the book. pub fn resolve_type_ctrs(&mut self) -> Result<(), Diagnostics> { for def in self.book.defs.values_mut() { let res = def.typ.resolve_type_ctrs(&self.book.adts); self.info.take_rule_err(res, def.name.clone()); } let adts = self.book.adts.clone(); for adt in self.book.adts.values_mut() { for ctr in adt.ctrs.values_mut() { let res = ctr.typ.resolve_type_ctrs(&adts); self.info.take_rule_err(res, ctr.name.clone()); for field in ctr.fields.iter_mut() { let res = field.typ.resolve_type_ctrs(&adts); self.info.take_rule_err(res, ctr.name.clone()); } } } self.info.fatal(()) } } impl Type { /// Resolves type constructors in the type. pub fn resolve_type_ctrs(&mut self, adts: &Adts) -> Result<(), String> { maybe_grow(|| { match self { Type::Var(nam) => { // If the variable actually refers to a type, we change the type to a constructor. if adts.contains_key(nam) { *self = Type::Ctr(nam.clone(), vec![]); } } Type::Ctr(name, args) => { if !adts.contains_key(name) { return Err(format!("Found unknown type constructor '{name}'.")); } for arg in args { arg.resolve_type_ctrs(adts)?; } } Type::Tup(els) => { for el in els { el.resolve_type_ctrs(adts)?; } } Type::Arr(lft, rgt) => { lft.resolve_type_ctrs(adts)?; rgt.resolve_type_ctrs(adts)?; } Type::Number(t) | Type::Integer(t) => t.resolve_type_ctrs(adts)?, Type::Any | Type::Hole | Type::None | Type::U24 | Type::I24 | Type::F24 => {} } Ok(()) }) } } ================================================ FILE: src/fun/transform/resugar_list.rs ================================================ use crate::{ fun::{builtins, Pattern, Tag, Term}, maybe_grow, AdtEncoding, }; impl Term { /// Converts lambda-encoded lists ending with List/Nil to list literals. pub fn resugar_lists(&mut self, adt_encoding: AdtEncoding) { match adt_encoding { AdtEncoding::Scott => self.resugar_lists_scott(), AdtEncoding::NumScott => self.resugar_lists_num_scott(), } } /// Converts num-scott-encoded lists ending with List/Nil to list literals. fn resugar_lists_num_scott(&mut self) { maybe_grow(|| { // Search for a List/Cons pattern in the term and try to build a list from that point on. // If successful, replace the term with the list. // If not, keep as-is. // Nil: List/nil if let Term::Ref { nam } = self { if nam == builtins::LNIL { *self = Term::List { els: vec![] }; } } // Cons: @x (x CONS_TAG ) if let Term::Lam { tag: Tag::Static, pat, bod } = self { if let Pattern::Var(Some(var_lam)) = pat.as_mut() { if let Term::App { tag: Tag::Static, fun, arg: tail } = bod.as_mut() { if let Term::App { tag: Tag::Static, fun, arg: head } = fun.as_mut() { if let Term::App { tag: Tag::Static, fun, arg } = fun.as_mut() { if let Term::Var { nam: var_app } = fun.as_mut() { if let Term::Ref { nam } = arg.as_mut() { if var_lam == var_app && nam == builtins::LCONS_TAG_REF { let l = build_list_num_scott(tail.as_mut(), vec![std::mem::take(head)]); match l { Ok(l) => *self = Term::List { els: l.into_iter().map(|x| *x).collect() }, // Was not a list term, keep as-is. Err(mut l) => { *head = l.pop().unwrap(); assert!(l.is_empty()) } } } } } } } } } } // Cons: (List/Cons ) if let Term::App { tag: Tag::Static, fun, arg: tail } = self { if let Term::App { tag: Tag::Static, fun, arg: head } = fun.as_mut() { if let Term::Ref { nam } = fun.as_mut() { if nam == builtins::LCONS { let l = build_list_num_scott(tail.as_mut(), vec![std::mem::take(head)]); match l { Ok(l) => *self = Term::List { els: l.into_iter().map(|x| *x).collect() }, // Was not a list term, keep as-is. Err(mut l) => { *head = l.pop().unwrap(); assert!(l.is_empty()) } } } } } } for child in self.children_mut() { child.resugar_lists_num_scott(); } }) } /// Converts scott-encoded lists ending with List/Nil to list literals. fn resugar_lists_scott(&mut self) { maybe_grow(|| { // Search for a List/Cons pattern in the term and try to build a list from that point on. // If successful, replace the term with the list. // If not, keep as-is. // Nil: List/nil if let Term::Ref { nam } = self { if nam == builtins::LNIL { *self = Term::List { els: vec![] }; } } // Cons: @* @c (c ) if let Term::Lam { tag: Tag::Static, pat, bod } = self { if let Pattern::Var(None) = pat.as_mut() { if let Term::Lam { tag: Tag::Static, pat, bod } = bod.as_mut() { if let Pattern::Var(Some(var_lam)) = pat.as_mut() { if let Term::App { tag: Tag::Static, fun, arg: tail } = bod.as_mut() { if let Term::App { tag: Tag::Static, fun, arg: head } = fun.as_mut() { if let Term::Var { nam: var_app } = fun.as_mut() { if var_lam == var_app { let l = build_list_scott(tail.as_mut(), vec![std::mem::take(head)]); match l { Ok(l) => *self = Term::List { els: l.into_iter().map(|x| *x).collect() }, // Was not a list term, keep as-is. Err(mut l) => { *head = l.pop().unwrap(); assert!(l.is_empty()) } } } } } } } } } } // Cons: (List/Cons ) if let Term::App { tag: Tag::Static, fun, arg: tail } = self { if let Term::App { tag: Tag::Static, fun, arg: head } = fun.as_mut() { if let Term::Ref { nam } = fun.as_mut() { if nam == builtins::LCONS { let l = build_list_scott(tail.as_mut(), vec![std::mem::take(head)]); match l { Ok(l) => *self = Term::List { els: l.into_iter().map(|x| *x).collect() }, // Was not a list term, keep as-is. Err(mut l) => { *head = l.pop().unwrap(); assert!(l.is_empty()) } } } } } } for child in self.children_mut() { child.resugar_lists_scott(); } }) } } // TODO: We have to do weird manipulations with Box because of the borrow checker. // When we used use box patterns this was a way simpler match statement. #[allow(clippy::vec_box)] fn build_list_num_scott(term: &mut Term, mut l: Vec>) -> Result>, Vec>> { maybe_grow(|| { // Nil: List/nil if let Term::Ref { nam } = term { if nam == builtins::LNIL { return Ok(l); } } // Cons: @x (x CONS_TAG ) if let Term::Lam { tag: Tag::Static, pat, bod } = term { if let Pattern::Var(Some(var_lam)) = pat.as_mut() { if let Term::App { tag: Tag::Static, fun, arg: tail } = bod.as_mut() { if let Term::App { tag: Tag::Static, fun, arg: head } = fun.as_mut() { if let Term::App { tag: Tag::Static, fun, arg } = fun.as_mut() { if let Term::Var { nam: var_app } = fun.as_mut() { if let Term::Ref { nam } = arg.as_mut() { if var_lam == var_app && nam == builtins::LCONS_TAG_REF { // New list element, append and recurse l.push(std::mem::take(head)); let l = build_list_num_scott(tail, l); match l { Ok(l) => return Ok(l), Err(mut l) => { // If it wasn't a list, we have to put it back. *head = l.pop().unwrap(); return Err(l); } } } } } } } } } } // Cons: (List/Cons ) if let Term::App { tag: Tag::Static, fun, arg: tail } = term { if let Term::App { tag: Tag::Static, fun, arg: head } = fun.as_mut() { if let Term::Ref { nam } = fun.as_mut() { if nam == builtins::LCONS { // New list element, append and recurse l.push(std::mem::take(head)); let l = build_list_num_scott(tail, l); match l { Ok(l) => return Ok(l), Err(mut l) => { // If it wasn't a list, we have to put it back. *head = l.pop().unwrap(); return Err(l); } } } } } } // Not a list term, stop Err(l) }) } #[allow(clippy::vec_box)] fn build_list_scott(term: &mut Term, mut l: Vec>) -> Result>, Vec>> { maybe_grow(|| { // Nil: List/nil if let Term::Ref { nam } = term { if nam == builtins::LNIL { return Ok(l); } } // Cons: @* @c (c ) if let Term::Lam { tag: Tag::Static, pat, bod } = term { if let Pattern::Var(None) = pat.as_mut() { if let Term::Lam { tag: Tag::Static, pat, bod } = bod.as_mut() { if let Pattern::Var(Some(var_lam)) = pat.as_mut() { if let Term::App { tag: Tag::Static, fun, arg: tail } = bod.as_mut() { if let Term::App { tag: Tag::Static, fun, arg: head } = fun.as_mut() { if let Term::Var { nam: var_app } = fun.as_mut() { if var_lam == var_app { // New list element, append and recurse l.push(std::mem::take(head)); let l = build_list_scott(tail, l); match l { Ok(l) => return Ok(l), Err(mut l) => { // If it wasn't a list, we have to put it back. *head = l.pop().unwrap(); return Err(l); } } } } } } } } } } // Cons: (List/Cons ) if let Term::App { tag: Tag::Static, fun, arg: tail } = term { if let Term::App { tag: Tag::Static, fun, arg: head } = fun.as_mut() { if let Term::Ref { nam } = fun.as_mut() { if nam == builtins::LCONS { // New list element, append and recurse l.push(std::mem::take(head)); let l = build_list_scott(tail, l); match l { Ok(l) => return Ok(l), Err(mut l) => { // If it wasn't a list, we have to put it back. *head = l.pop().unwrap(); return Err(l); } } } } } } // Not a list term, stop Err(l) }) } ================================================ FILE: src/fun/transform/resugar_string.rs ================================================ use crate::{ fun::{builtins, Name, Num, Pattern, Tag, Term}, maybe_grow, AdtEncoding, }; impl Term { /// Converts lambda-encoded strings ending with String/nil to string literals. pub fn resugar_strings(&mut self, adt_encoding: AdtEncoding) { match adt_encoding { AdtEncoding::Scott => self.try_resugar_strings_with(Self::resugar_strings_scott), AdtEncoding::NumScott => self.try_resugar_strings_with(Self::resugar_strings_num_scott), } } /// Converts encoded strings to string literals using the provided extraction function. fn try_resugar_strings_with(&mut self, extract_fn: fn(&Term) -> Option<(char, &Term)>) { maybe_grow(|| { // Try to resugar nil or cons patterns. If unsuccessful, recurse into child terms. if !self.try_resugar_strings_nil() && !self.try_resugar_strings_cons(extract_fn) { for child in self.children_mut() { child.try_resugar_strings_with(extract_fn); } } }) } /// Attempts to resugar a nil term (String/nil) to an empty string literal. fn try_resugar_strings_nil(&mut self) -> bool { matches!(self, Term::Ref { nam } if nam == builtins::SNIL).then(|| *self = Term::str("")).is_some() } /// Attempts to resugar a cons term to a string literal. fn try_resugar_strings_cons(&mut self, extract_fn: fn(&Term) -> Option<(char, &Term)>) -> bool { self .try_resugar_strings_cons_with(extract_fn) .or_else(|| self.try_resugar_strings_cons_common()) .map(|str| *self = Term::str(&str)) .is_some() } /// Attempts to resugar a cons term using the provided extraction function. fn try_resugar_strings_cons_with(&self, extract_fn: fn(&Term) -> Option<(char, &Term)>) -> Option { extract_fn(self) .and_then(|(head_char, tail)| Self::build_strings_common(tail, head_char.to_string(), extract_fn)) } /// Attempts to resugar a cons term using the common extraction method. fn try_resugar_strings_cons_common(&self) -> Option { if let Term::App { tag: Tag::Static, fun, arg: tail } = self { if let Term::App { tag: Tag::Static, fun: inner_fun, arg: head } = fun.as_ref() { if let (Term::Ref { nam }, Term::Num { val: Num::U24(head_val) }) = (inner_fun.as_ref(), head.as_ref()) { if nam == builtins::SCONS { let head_char = char::from_u32(*head_val).unwrap_or(char::REPLACEMENT_CHARACTER); return Self::build_strings_common(tail, head_char.to_string(), Self::extract_strings_common); } } } } None } /// Builds a string from a term structure using the provided extraction function. fn build_strings_common( term: &Term, mut s: String, extract_fn: fn(&Term) -> Option<(char, &Term)>, ) -> Option { maybe_grow(|| { let mut current = term; loop { match current { // If we reach a nil term, we've completed the string Term::Ref { nam } if nam == builtins::SNIL => return Some(s), _ => { // Extract the next character and continue building the string let (head, next) = extract_fn(current).or_else(|| Self::extract_strings_common(current))?; s.push(head); current = next; } } } }) } /// Extracts a character and the remaining term from a Scott-encoded string term. /// The structure of this function mimics the shape of the AST for easier visualization. fn resugar_strings_scott(term: &Term) -> Option<(char, &Term)> { if let Term::Lam { tag: Tag::Static, pat: outer_pat, bod } = term { if let Pattern::Var(None) = outer_pat.as_ref() { if let Term::Lam { tag: Tag::Static, pat: inner_pat, bod: inner_bod } = bod.as_ref() { if let Pattern::Var(Some(var_lam)) = inner_pat.as_ref() { if let Term::App { tag: Tag::Static, fun, arg: tail } = inner_bod.as_ref() { if let Term::App { tag: Tag::Static, fun: inner_fun, arg: head } = fun.as_ref() { if let (Term::Var { nam: var_app }, Term::Num { val: Num::U24(head_val) }) = (inner_fun.as_ref(), head.as_ref()) { if var_lam == var_app { let head_char = char::from_u32(*head_val).unwrap_or(char::REPLACEMENT_CHARACTER); return Some((head_char, tail)); } } } } } } } } None } /// Extracts a character and the remaining term from a NumScott-encoded string term. /// The structure of this function mimics the shape of the AST for easier visualization. fn resugar_strings_num_scott(term: &Term) -> Option<(char, &Term)> { if let Term::Lam { tag: Tag::Static, pat, bod } = term { if let Pattern::Var(Some(var_lam)) = pat.as_ref() { if let Term::App { tag: Tag::Static, fun, arg: tail } = bod.as_ref() { if let Term::App { tag: Tag::Static, fun, arg: head } = fun.as_ref() { if let Term::App { tag: Tag::Static, fun, arg } = fun.as_ref() { if let ( Term::Var { nam: var_app }, Term::Ref { nam: Name(ref_nam) }, Term::Num { val: Num::U24(head_val) }, ) = (fun.as_ref(), arg.as_ref(), head.as_ref()) { if var_lam == var_app && ref_nam == builtins::SCONS_TAG_REF { let head_char = char::from_u32(*head_val).unwrap_or(char::REPLACEMENT_CHARACTER); return Some((head_char, tail)); } } } } } } } None } /// Extracts a character and the remaining term from a common-encoded string term. /// The structure of this function mimics the shape of the AST for easier visualization. fn extract_strings_common(term: &Term) -> Option<(char, &Term)> { if let Term::App { tag: Tag::Static, fun, arg: tail } = term { if let Term::App { tag: Tag::Static, fun, arg: head } = fun.as_ref() { if let (Term::Ref { nam }, Term::Num { val: Num::U24(head_val) }) = (fun.as_ref(), head.as_ref()) { if nam == builtins::SCONS { let head_char = char::from_u32(*head_val).unwrap_or(char::REPLACEMENT_CHARACTER); return Some((head_char, tail)); } } } } None } } ================================================ FILE: src/fun/transform/unique_names.rs ================================================ // Pass to give all variables in a definition unique names. use crate::{ fun::{Book, Name, Term}, maybe_grow, }; use std::collections::HashMap; impl Book { /// Makes all variables in each definition have a new unique name. /// Skips unbound variables. /// Precondition: Definition references have been resolved. pub fn make_var_names_unique(&mut self) { for def in self.defs.values_mut() { def.rule_mut().body.make_var_names_unique(); } } } impl Term { pub fn make_var_names_unique(&mut self) { UniqueNameGenerator::default().unique_names_in_term(self); } } type VarId = u64; #[derive(Default)] pub struct UniqueNameGenerator { name_map: HashMap>, name_count: VarId, } impl UniqueNameGenerator { // Recursively assign an id to each variable in the term, then convert each id into a unique name. pub fn unique_names_in_term(&mut self, term: &mut Term) { // Note: we can't use the children iterators here because we mutate the binds, // which are shared across multiple children. maybe_grow(|| match term { Term::Var { nam } => *nam = self.use_var(nam), Term::Mat { bnd, arg, with_bnd, with_arg, arms } | Term::Fold { bnd, arg, with_bnd, with_arg, arms } => { // Process args self.unique_names_in_term(arg); for arg in with_arg { self.unique_names_in_term(arg); } // Add binds shared by all arms self.push(bnd.as_ref()); for bnd in with_bnd.iter() { self.push(bnd.as_ref()); } // Process arms for arm in arms { // Add binds unique to each arm for bnd in arm.1.iter() { self.push(bnd.as_ref()); } // Process arm body self.unique_names_in_term(&mut arm.2); // Remove binds unique to each arm for bnd in arm.1.iter_mut() { *bnd = self.pop(bnd.as_ref()); } } // Remove binds shared by all arms for bnd in with_bnd { *bnd = self.pop(bnd.as_ref()); } *bnd = self.pop(bnd.as_ref()); } Term::Swt { bnd, arg, with_bnd, with_arg, pred, arms } => { self.unique_names_in_term(arg); for arg in with_arg { self.unique_names_in_term(arg); } self.push(bnd.as_ref()); for bnd in with_bnd.iter() { self.push(bnd.as_ref()); } let (succ, nums) = arms.split_last_mut().unwrap(); for arm in nums.iter_mut() { self.unique_names_in_term(arm); } self.push(pred.as_ref()); self.unique_names_in_term(succ); *pred = self.pop(pred.as_ref()); for bnd in with_bnd { *bnd = self.pop(bnd.as_ref()); } *bnd = self.pop(bnd.as_ref()); } Term::Bend { bnd, arg, cond, step, base } => { for arg in arg { self.unique_names_in_term(arg); } for bnd in bnd.iter() { self.push(bnd.as_ref()); } self.unique_names_in_term(cond); self.unique_names_in_term(step); self.unique_names_in_term(base); for bnd in bnd { *bnd = self.pop(bnd.as_ref()); } } Term::Let { pat, val, nxt } | Term::Ask { pat, val, nxt } => { self.unique_names_in_term(val); for bnd in pat.binds() { self.push(bnd.as_ref()); } self.unique_names_in_term(nxt); for bind in pat.binds_mut() { *bind = self.pop(bind.as_ref()); } } Term::Use { nam, val, nxt } => { self.unique_names_in_term(val); self.push(nam.as_ref()); self.unique_names_in_term(nxt); *nam = self.pop(nam.as_ref()); } Term::Lam { tag: _, pat, bod } => { for bind in pat.binds() { self.push(bind.as_ref()); } self.unique_names_in_term(bod); for bind in pat.binds_mut() { *bind = self.pop(bind.as_ref()); } } Term::Fan { fan: _, tag: _, els } | Term::List { els } => { for el in els { self.unique_names_in_term(el); } } Term::App { tag: _, fun: fst, arg: snd } | Term::Oper { opr: _, fst, snd } => { self.unique_names_in_term(fst); self.unique_names_in_term(snd); } Term::With { typ: _, bod } => { self.unique_names_in_term(bod); } Term::Link { .. } | Term::Num { .. } | Term::Nat { .. } | Term::Str { .. } | Term::Ref { .. } | Term::Era | Term::Err => {} Term::Open { .. } => unreachable!("'open' should be removed in earlier pass"), Term::Def { .. } => unreachable!("'def' should be removed in earlier pass"), }) } fn push(&mut self, nam: Option<&Name>) { if let Some(name) = nam { if let Some(ids) = self.name_map.get_mut(name) { ids.push(self.name_count); } else { self.name_map.insert(name.clone(), vec![self.name_count]); } self.name_count += 1; } } fn pop(&mut self, nam: Option<&Name>) -> Option { if let Some(name) = nam { let var_id = self.name_map.get_mut(name).unwrap().pop().unwrap(); if self.name_map[name].is_empty() { self.name_map.remove(name); } Some(Name::from(var_id)) } else { None } } fn use_var(&self, nam: &Name) -> Name { if let Some(vars) = self.name_map.get(nam) { let var_id = *vars.last().unwrap(); Name::from(var_id) } else { // Skip unbound variables. // With this, we can use this function before checking for unbound vars. nam.clone() } } } ================================================ FILE: src/hvm/add_recursive_priority.rs ================================================ use super::tree_children; use crate::maybe_grow; use hvm::ast::{Book, Net, Tree}; use std::collections::{HashMap, HashSet}; pub fn add_recursive_priority(book: &mut Book) { // Direct dependencies let deps = book.defs.iter().map(|(nam, net)| (nam.clone(), dependencies(net))).collect::>(); // Recursive cycles let cycles = cycles(&deps); for cycle in cycles { // For each function in the cycle, if there are redexes with the // next ref in the cycle, add a priority to one of those redexes. for i in 0..cycle.len() { let cur = book.defs.get_mut(&cycle[i]).unwrap(); let nxt = &cycle[(i + 1) % cycle.len()]; add_priority_next_in_cycle(cur, nxt); } } } fn add_priority_next_in_cycle(net: &mut Net, nxt: &String) { let mut count = 0; // Count the number of recursive refs for (_, a, b) in net.rbag.iter() { if let Tree::Ref { nam } = a { if nam == nxt { count += 1; } } if let Tree::Ref { nam } = b { if nam == nxt { count += 1; } } } // If there are more than one recursive ref, add a priority to them. if count > 1 { for (pri, a, b) in net.rbag.iter_mut().rev() { if let Tree::Ref { nam } = a { if nam == nxt { *pri = true; } } if let Tree::Ref { nam } = b { if nam == nxt { *pri = true; } } } } } type DepGraph = HashMap>; type Cycles = Vec>; /// Find all cycles in the dependency graph. pub fn cycles(deps: &DepGraph) -> Cycles { let mut cycles = vec![]; let mut stack = vec![]; let mut visited = HashSet::new(); for nam in deps.keys() { if !visited.contains(nam) { find_cycles(deps, nam, &mut visited, &mut stack, &mut cycles); } } cycles } fn find_cycles( deps: &DepGraph, nam: &String, visited: &mut HashSet, stack: &mut Vec, cycles: &mut Cycles, ) { maybe_grow(|| { // Check if the current ref is already in the stack, which indicates a cycle. if let Some(cycle_start) = stack.iter().position(|n| n == nam) { // If found, add the cycle to the cycles vector. cycles.push(stack[cycle_start..].to_vec()); return; } // If the ref has not been visited yet, mark it as visited. if visited.insert(nam.clone()) { // Add the current ref to the stack to keep track of the path. stack.push(nam.clone()); // Get the dependencies of the current ref. if let Some(dependencies) = deps.get(nam) { // Search for cycles from each dependency. for dep in dependencies { find_cycles(deps, dep, visited, stack, cycles); } } stack.pop(); } }) } /// Gather the set of net that this net directly depends on (has a ref in the net). fn dependencies(net: &Net) -> HashSet { let mut deps = HashSet::new(); dependencies_tree(&net.root, &mut deps); for (_, a, b) in &net.rbag { dependencies_tree(a, &mut deps); dependencies_tree(b, &mut deps); } deps } fn dependencies_tree(tree: &Tree, deps: &mut HashSet) { if let Tree::Ref { nam, .. } = tree { deps.insert(nam.clone()); } else { for subtree in tree_children(tree) { dependencies_tree(subtree, deps); } } } ================================================ FILE: src/hvm/check_net_size.rs ================================================ use super::tree_children; use crate::{diagnostics::Diagnostics, fun::Name, CompilerTarget}; use hvm::ast::{Book, Net, Tree}; pub const MAX_NET_SIZE_C: usize = 4095; pub const MAX_NET_SIZE_CUDA: usize = 64; pub fn check_net_sizes( book: &Book, diagnostics: &mut Diagnostics, target: &CompilerTarget, ) -> Result<(), Diagnostics> { let (net_size_bound, target_lang) = match target { CompilerTarget::Cuda => (MAX_NET_SIZE_CUDA, "Cuda"), _ => (MAX_NET_SIZE_C, "C"), }; for (name, net) in &book.defs { let nodes = count_nodes(net); if nodes > net_size_bound { diagnostics.add_function_error( format!("Definition is too large for HVM {target_lang} (size={nodes}, max size={net_size_bound}). Please break it into smaller pieces."), Name::new(name), Default::default() ); } } diagnostics.fatal(()) } /// Utility function to count the amount of nodes in an hvm-core AST net pub fn count_nodes(net: &Net) -> usize { let mut visit: Vec<&Tree> = vec![&net.root]; let mut count = 0usize; for (_, l, r) in &net.rbag { visit.push(l); visit.push(r); } while let Some(tree) = visit.pop() { // If it is not 0-ary, then we'll count it as a node. if tree_children(tree).next().is_some() { count += 1; } for subtree in tree_children(tree) { visit.push(subtree); } } count } ================================================ FILE: src/hvm/eta_reduce.rs ================================================ //! Carries out simple eta-reduction, to reduce the amount of rewrites at //! runtime. //! //! ### Eta-equivalence //! //! In interaction combinators, there are some nets that are equivalent and //! have no observable difference //! //! ![Image of eta-equivalence](https://i.postimg.cc/XYVxdMFW/image.png) //! //! This module implements the eta-equivalence rule at the top-left of the image //! above //! //! ```txt //! /|-, ,-|\ eta_reduce //! ---| | X | |-- ~~~~~~~~~~~~> ------------- //! \|-' '-|/ //! ``` //! //! In hvm-core's AST representation, this reduction looks like this //! //! ```txt //! {lab x y} ... {lab x y} ~~~~~~~~> x ..... x //! ``` //! //! Essentially, both occurrences of the same constructor are replaced by a //! variable. //! //! ### The algorithm //! //! The code uses a two-pass O(n) algorithm, where `n` is the amount of nodes //! in the AST //! //! In the first pass, a node-list is built out of an ordered traversal of the //! AST. Crucially, the node list stores variable offsets instead of the //! variable's names Since the AST's order is consistent, the ordering of nodes //! in the node list can be reproduced with a traversal. //! //! This means that each occurrence of a variable is encoded with the offset in //! the node-list to the _other_ occurrence of the variable. //! //! For example, if we start with the net: `[(x y) (x y)]` //! //! The resulting node list will look like this: //! //! `[Ctr(1), Ctr(0), Var(3), Var(3), Ctr(0), Var(-3), Var(-3)]` //! //! The second pass uses the node list to find repeated constructors. If a //! constructor's children are both variables with the same offset, then we //! lookup that offset relative to the constructor. If it is equal to the first //! constructor, it means both of them are equal and they can be replaced with a //! variable. //! //! The pass also reduces subnets such as `(* *) -> *` use crate::hvm::net_trees_mut; use super::{tree_children, tree_children_mut}; use core::ops::RangeFrom; use hvm::ast::{Net, Tree}; use std::collections::HashMap; /// Carries out simple eta-reduction pub fn eta_reduce_hvm_net(net: &mut Net) { let mut phase1 = Phase1::default(); for tree in net_trees_mut(net) { phase1.walk_tree(tree); } let mut phase2 = Phase2 { nodes: phase1.nodes, index: 0.. }; for tree in net_trees_mut(net) { phase2.reduce_tree(tree); } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] enum NodeType { Ctr(u16), Var(isize), Era, Other, Hole, } #[derive(Default, Debug)] struct Phase1<'a> { vars: HashMap<&'a str, usize>, nodes: Vec, } impl<'a> Phase1<'a> { fn walk_tree(&mut self, tree: &'a Tree) { match tree { Tree::Con { fst, snd } => { self.nodes.push(NodeType::Ctr(0)); self.walk_tree(fst); self.walk_tree(snd); } Tree::Dup { fst, snd } => { self.nodes.push(NodeType::Ctr(1)); self.walk_tree(fst); self.walk_tree(snd); } Tree::Var { nam } => { if let Some(i) = self.vars.get(&**nam) { let j = self.nodes.len() as isize; self.nodes.push(NodeType::Var(*i as isize - j)); self.nodes[*i] = NodeType::Var(j - *i as isize); } else { self.vars.insert(nam, self.nodes.len()); self.nodes.push(NodeType::Hole); } } Tree::Era => self.nodes.push(NodeType::Era), _ => { self.nodes.push(NodeType::Other); for i in tree_children(tree) { self.walk_tree(i); } } } } } struct Phase2 { nodes: Vec, index: RangeFrom, } impl Phase2 { fn reduce_ctr(&mut self, tree: &mut Tree, idx: usize) -> NodeType { if let Tree::Con { fst, snd } | Tree::Dup { fst, snd } = tree { let fst_typ = self.reduce_tree(fst); let snd_typ = self.reduce_tree(snd); // If both children are variables with the same offset, and their parent is a ctr of the same label, // then they are eta-reducible and we replace the current node with the first variable. match (fst_typ, snd_typ) { (NodeType::Var(off_lft), NodeType::Var(off_rgt)) => { if off_lft == off_rgt && self.nodes[idx] == self.nodes[(idx as isize + off_lft) as usize] { let Tree::Var { nam } = fst.as_mut() else { unreachable!() }; *tree = Tree::Var { nam: std::mem::take(nam) }; return NodeType::Var(off_lft); } } (NodeType::Era, NodeType::Era) => { *tree = Tree::Era; return NodeType::Era; } _ => {} } self.nodes[idx] } else { unreachable!() } } fn reduce_tree(&mut self, tree: &mut Tree) -> NodeType { let idx = self.index.next().unwrap(); match tree { Tree::Con { .. } | Tree::Dup { .. } => self.reduce_ctr(tree, idx), _ => { for child in tree_children_mut(tree) { self.reduce_tree(child); } self.nodes[idx] } } } } ================================================ FILE: src/hvm/inline.rs ================================================ use super::{net_trees_mut, tree_children, tree_children_mut}; use crate::maybe_grow; use core::ops::BitOr; use hvm::ast::{Book, Net, Tree}; use std::collections::{HashMap, HashSet}; pub fn inline_hvm_book(book: &mut Book) -> Result, String> { let mut state = InlineState::default(); state.populate_inlinees(book)?; let mut all_changed = HashSet::new(); for (name, net) in &mut book.defs { let mut inlined = false; for tree in net_trees_mut(net) { inlined |= state.inline_into(tree); } if inlined { all_changed.insert(name.to_owned()); } } Ok(all_changed) } #[derive(Debug, Default)] struct InlineState { inlinees: HashMap, } impl InlineState { fn populate_inlinees(&mut self, book: &Book) -> Result<(), String> { for (name, net) in &book.defs { if should_inline(net) { // Detect cycles with tortoise and hare algorithm let mut hare = &net.root; let mut tortoise = &net.root; // Whether or not the tortoise should take a step let mut parity = false; while let Tree::Ref { nam, .. } = hare { let Some(net) = &book.defs.get(nam) else { break }; if should_inline(net) { hare = &net.root; } else { break; } if parity { let Tree::Ref { nam: tortoise_nam, .. } = tortoise else { unreachable!() }; if tortoise_nam == nam { Err(format!("infinite reference cycle in `@{nam}`"))?; } tortoise = &book.defs[tortoise_nam].root; } parity = !parity; } self.inlinees.insert(name.to_owned(), hare.clone()); } } Ok(()) } fn inline_into(&self, tree: &mut Tree) -> bool { maybe_grow(|| { let Tree::Ref { nam, .. } = &*tree else { return tree_children_mut(tree).map(|t| self.inline_into(t)).fold(false, bool::bitor); }; if let Some(inlined) = self.inlinees.get(nam) { *tree = inlined.clone(); true } else { false } }) } } fn should_inline(net: &Net) -> bool { net.rbag.is_empty() && tree_children(&net.root).next().is_none() } ================================================ FILE: src/hvm/mod.rs ================================================ use crate::multi_iterator; use hvm::ast::{Net, Tree}; pub mod add_recursive_priority; pub mod check_net_size; pub mod eta_reduce; pub mod inline; pub mod mutual_recursion; pub mod prune; pub fn tree_children(tree: &Tree) -> impl DoubleEndedIterator + Clone { multi_iterator!(ChildrenIter { Zero, Two }); match tree { Tree::Var { .. } | Tree::Ref { .. } | Tree::Era | Tree::Num { .. } => ChildrenIter::Zero([]), Tree::Con { fst, snd } | Tree::Dup { fst, snd } | Tree::Opr { fst, snd } | Tree::Swi { fst, snd } => { ChildrenIter::Two([fst.as_ref(), snd.as_ref()]) } } } pub fn tree_children_mut(tree: &mut Tree) -> impl DoubleEndedIterator { multi_iterator!(ChildrenIter { Zero, Two }); match tree { Tree::Var { .. } | Tree::Ref { .. } | Tree::Era | Tree::Num { .. } => ChildrenIter::Zero([]), Tree::Con { fst, snd } | Tree::Dup { fst, snd } | Tree::Opr { fst, snd } | Tree::Swi { fst, snd } => { ChildrenIter::Two([fst.as_mut(), snd.as_mut()]) } } } pub fn net_trees(net: &Net) -> impl DoubleEndedIterator + Clone { [&net.root].into_iter().chain(net.rbag.iter().flat_map(|(_, fst, snd)| [fst, snd])) } pub fn net_trees_mut(net: &mut Net) -> impl DoubleEndedIterator { [&mut net.root].into_iter().chain(net.rbag.iter_mut().flat_map(|(_, fst, snd)| [fst, snd])) } pub fn hvm_book_show_pretty(book: &hvm::ast::Book) -> String { let mut s = String::new(); for (nam, def) in book.defs.iter() { s.push_str(&format!("@{} = {}\n", nam, def.root.show())); for (pri, a, b) in def.rbag.iter() { s.push_str(" &"); if *pri { s.push('!'); } else { s.push(' '); } s.push_str(&a.show()); s.push_str(" ~ "); s.push_str(&b.show()); s.push('\n'); } s.push('\n'); } s } ================================================ FILE: src/hvm/mutual_recursion.message ================================================ The following functions contain recursive cycles incompatible with HVM's strict evaluation: {cycles} The greedy eager evaluation of HVM may cause infinite loops. Refactor these functions to use lazy references instead of direct function calls. A reference is strict when it's being called ('(Foo x)') or when it's used non-linearly ('let x = Foo; (x x)'). It is lazy when it's an argument ('(x Foo)') or when it's used linearly ('let x = Foo; (x 0)'). Try one of these strategies: - Use pattern matching with 'match', 'fold', and 'bend' to automatically lift expressions to lazy references. - Replace direct calls with combinators. For example, change: 'Foo = λa λb (b (λc (Foo a c)) a)' to: 'Foo = λa λb (b (λc λa (Foo a c)) (λa a) a)' which is lifted to: 'Foo = λa λb (b Foo__C1 Foo__C2 a)' - Replace non-linear 'let' expressions with 'use' expressions. For example, change: 'Foo = λf let x = Foo; (f x x)' to: 'Foo = λf use x = Foo; (f x x)' which inlines to: 'Foo = λf (f Foo Foo)' - If disabled, re-enable the default 'float-combinators' and 'linearize-matches' compiler options. For more information, visit: https://github.com/HigherOrderCO/Bend/blob/main/docs/lazy-definitions.md. To disable this check, use the "-Arecursion-cycle" compiler option. ================================================ FILE: src/hvm/mutual_recursion.rs ================================================ use super::tree_children; use crate::{ diagnostics::{Diagnostics, WarningType, ERR_INDENT_SIZE}, fun::transform::definition_merge::MERGE_SEPARATOR, maybe_grow, }; use hvm::ast::{Book, Tree}; use indexmap::{IndexMap, IndexSet}; use std::fmt::Debug; type Ref = String; type Stack = Vec; type RefSet = IndexSet; #[derive(Default)] pub struct Graph(IndexMap); pub fn check_cycles(book: &Book, diagnostics: &mut Diagnostics) -> Result<(), Diagnostics> { let graph = Graph::from(book); let cycles = graph.cycles(); if !cycles.is_empty() { let msg = format!(include_str!("mutual_recursion.message"), cycles = show_cycles(cycles)); diagnostics.add_book_warning(msg.as_str(), WarningType::RecursionCycle); } diagnostics.fatal(()) } fn show_cycles(mut cycles: Vec>) -> String { let tail = if cycles.len() > 5 { format!("\n{:ERR_INDENT_SIZE$}and {} other cycles...", "", cycles.len() - 5) } else { String::new() }; cycles = cycles.into_iter().flat_map(combinations_from_merges).collect::>(); let mut cycles = cycles .iter() .take(5) .map(|cycle| { let cycle_str = cycle .iter() .filter(|nam| !nam.contains("__C")) .chain(cycle.first()) .cloned() .collect::>() .join(" -> "); format!("{:ERR_INDENT_SIZE$}* {}", "", cycle_str) }) .collect::>() .join("\n"); cycles.push_str(&tail); cycles } impl Graph { pub fn cycles(&self) -> Vec> { let mut cycles = Vec::new(); let mut stack = Stack::new(); let mut visited = RefSet::new(); for r#ref in self.0.keys() { if !visited.contains(r#ref) { self.find_cycles(r#ref, &mut visited, &mut stack, &mut cycles); } } cycles } fn find_cycles( &self, r#ref: &Ref, visited: &mut RefSet, stack: &mut Stack, cycles: &mut Vec>, ) { // Check if the current ref is already in the stack, which indicates a cycle. if let Some(cycle_start) = stack.iter().position(|n| n == r#ref) { // If found, add the cycle to the cycles vector. cycles.push(stack[cycle_start..].to_vec()); return; } // If the ref has not been visited yet, mark it as visited. if visited.insert(r#ref.clone()) { // Add the current ref to the stack to keep track of the path. stack.push(r#ref.clone()); // Get the dependencies of the current ref. if let Some(dependencies) = self.get(r#ref) { // Search for cycles from each dependency. for dep in dependencies { self.find_cycles(dep, visited, stack, cycles); } } stack.pop(); } } } /// Collect active refs from the tree. fn collect_refs(current: Ref, tree: &Tree, graph: &mut Graph) { maybe_grow(|| match tree { Tree::Ref { nam, .. } => graph.add(current, nam.clone()), Tree::Con { fst: _, snd } => collect_refs(current.clone(), snd, graph), tree => { for subtree in tree_children(tree) { collect_refs(current.clone(), subtree, graph); } } }); } impl From<&Book> for Graph { fn from(book: &Book) -> Self { let mut graph = Self::new(); for (r#ref, net) in book.defs.iter() { // Collect active refs from the root. collect_refs(r#ref.clone(), &net.root, &mut graph); // Collect active refs from redexes. for (_, left, right) in net.rbag.iter() { if let Tree::Ref { nam, .. } = left { graph.add(r#ref.clone(), nam.clone()); } if let Tree::Ref { nam, .. } = right { graph.add(r#ref.clone(), nam.clone()); } } } graph } } impl Graph { pub fn new() -> Self { Self::default() } pub fn add(&mut self, r#ref: Ref, dependency: Ref) { self.0.entry(r#ref).or_default().insert(dependency.clone()); self.0.entry(dependency).or_default(); } pub fn get(&self, r#ref: &Ref) -> Option<&RefSet> { self.0.get(r#ref) } } impl Debug for Graph { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "Graph{:?}", self.0) } } fn combinations_from_merges(cycle: Vec) -> Vec> { let mut combinations: Vec> = vec![vec![]]; for r#ref in cycle { if let Some(index) = r#ref.find(MERGE_SEPARATOR) { let (left, right) = r#ref.split_at(index); let right = &right[MERGE_SEPARATOR.len()..]; // skip merge separator let mut new_combinations = Vec::new(); for combination in &combinations { let mut left_comb = combination.clone(); left_comb.push(left.to_string()); new_combinations.push(left_comb); let mut right_comb = combination.clone(); right_comb.push(right.to_string()); new_combinations.push(right_comb); } combinations = new_combinations; } else { for combination in &mut combinations { combination.push(r#ref.clone()); } } } combinations } ================================================ FILE: src/hvm/prune.rs ================================================ use super::{net_trees, tree_children}; use crate::maybe_grow; use hvm::ast::{Book, Tree}; use std::collections::HashSet; pub fn prune_hvm_book(book: &mut Book, entrypoints: &[String]) { let mut state = PruneState { book, unvisited: book.defs.keys().map(|x| x.to_owned()).collect() }; for name in entrypoints { state.visit_def(name); } let unvisited = state.unvisited; for name in unvisited { book.defs.remove(&name); } } struct PruneState<'a> { book: &'a Book, unvisited: HashSet, } impl PruneState<'_> { fn visit_def(&mut self, name: &str) { if self.unvisited.remove(name) { for tree in net_trees(&self.book.defs[name]) { self.visit_tree(tree); } } } fn visit_tree(&mut self, tree: &Tree) { maybe_grow(|| { if let Tree::Ref { nam, .. } = tree { self.visit_def(nam); } else { tree_children(tree).for_each(|t| self.visit_tree(t)); } }) } } ================================================ FILE: src/imp/gen_map_get.rs ================================================ use crate::fun::Name; use super::{AssignPattern, Definition, Expr, Stmt}; impl Definition { /// Generates a map from `Stmt` to `Substitutions` for each definition in the program. /// Iterates over all definitions in the program and applies `gen_map_get` to their bodies. /// It replaces `Expr::MapGet` expressions with variable accesses, introducing /// new variables as necessary to hold intermediate results from map accesses. pub fn gen_map_get(&mut self) { self.body.gen_map_get(&mut 0); } } impl Stmt { fn gen_map_get(&mut self, id: &mut usize) { match self { Stmt::LocalDef { def, nxt } => { nxt.gen_map_get(id); def.gen_map_get() } Stmt::Assign { pat, val, nxt } => { let key_substitutions = if let AssignPattern::MapSet(_, key) = pat { key.substitute_map_gets(id) } else { Vec::new() }; if let Some(nxt) = nxt { nxt.gen_map_get(id); } let substitutions = val.substitute_map_gets(id); if !substitutions.is_empty() { *self = gen_get(self, substitutions); } if !key_substitutions.is_empty() { *self = gen_get(self, key_substitutions); } } Stmt::Ask { pat: _, val, nxt } => { if let Some(nxt) = nxt { nxt.gen_map_get(id); } let substitutions = val.substitute_map_gets(id); if !substitutions.is_empty() { *self = gen_get(self, substitutions); } } Stmt::InPlace { op: _, pat, val, nxt } => { let key_substitutions = if let AssignPattern::MapSet(_, key) = &mut **pat { key.substitute_map_gets(id) } else { Vec::new() }; nxt.gen_map_get(id); let substitutions = val.substitute_map_gets(id); if !substitutions.is_empty() { *self = gen_get(self, substitutions); } if !key_substitutions.is_empty() { *self = gen_get(self, key_substitutions); } } Stmt::If { cond, then, otherwise, nxt } => { then.gen_map_get(id); otherwise.gen_map_get(id); if let Some(nxt) = nxt { nxt.gen_map_get(id); } let substitutions = cond.substitute_map_gets(id); if !substitutions.is_empty() { *self = gen_get(self, substitutions); } } Stmt::Match { bnd: _, arg, with_bnd: _, with_arg, arms, nxt } | Stmt::Fold { bnd: _, arg, arms, with_bnd: _, with_arg, nxt } => { for arm in arms.iter_mut() { arm.rgt.gen_map_get(id); } if let Some(nxt) = nxt { nxt.gen_map_get(id); } let mut substitutions = arg.substitute_map_gets(id); for arg in with_arg { substitutions.extend(arg.substitute_map_gets(id)); } if !substitutions.is_empty() { *self = gen_get(self, substitutions); } } Stmt::Switch { bnd: _, arg, with_bnd: _, with_arg, arms, nxt } => { for arm in arms.iter_mut() { arm.gen_map_get(id); } if let Some(nxt) = nxt { nxt.gen_map_get(id); } let mut substitutions = arg.substitute_map_gets(id); for arg in with_arg { substitutions.extend(arg.substitute_map_gets(id)); } if !substitutions.is_empty() { *self = gen_get(self, substitutions); } } Stmt::Bend { bnd: _, arg: init, cond, step, base, nxt } => { step.gen_map_get(id); base.gen_map_get(id); if let Some(nxt) = nxt { nxt.gen_map_get(id); } let mut substitutions = cond.substitute_map_gets(id); for init in init { substitutions.extend(init.substitute_map_gets(id)); } if !substitutions.is_empty() { *self = gen_get(self, substitutions); } } Stmt::With { typ: _, bod, nxt } => { bod.gen_map_get(id); if let Some(nxt) = nxt { nxt.gen_map_get(id); } } Stmt::Return { term } => { let substitutions = term.substitute_map_gets(id); if !substitutions.is_empty() { *self = gen_get(self, substitutions); } } Stmt::Open { typ: _, var: _, nxt } => { nxt.gen_map_get(id); } Stmt::Use { nam: _, val: bod, nxt } => { nxt.gen_map_get(id); let substitutions = bod.substitute_map_gets(id); if !substitutions.is_empty() { *self = gen_get(self, substitutions); } } Stmt::Err => {} } } } type Substitutions = Vec<(Name, Name, Box)>; impl Expr { fn substitute_map_gets(&mut self, id: &mut usize) -> Substitutions { fn go(e: &mut Expr, substitutions: &mut Substitutions, id: &mut usize) { match e { Expr::MapGet { nam, key } => { go(key, substitutions, id); let new_var = gen_map_var(id); substitutions.push((new_var.clone(), nam.clone(), key.clone())); *e = Expr::Var { nam: new_var }; } Expr::Call { fun, args, kwargs } => { go(fun, substitutions, id); for arg in args { go(arg, substitutions, id); } for (_, arg) in kwargs { go(arg, substitutions, id); } } Expr::Lam { bod, .. } => { go(bod, substitutions, id); } Expr::Opr { lhs, rhs, .. } => { go(lhs, substitutions, id); go(rhs, substitutions, id); } Expr::Lst { els } | Expr::Tup { els } | Expr::Sup { els } => { for el in els { go(el, substitutions, id); } } Expr::Ctr { kwargs, .. } => { for (_, arg) in kwargs.iter_mut() { go(arg, substitutions, id); } } Expr::LstMap { term, iter, cond, .. } => { go(term, substitutions, id); go(iter, substitutions, id); if let Some(cond) = cond { go(cond, substitutions, id); } } Expr::Map { entries } => { for (_, entry) in entries { go(entry, substitutions, id); } } Expr::TreeNode { left, right } => { go(left, substitutions, id); go(right, substitutions, id); } Expr::TreeLeaf { val } => { go(val, substitutions, id); } Expr::Era | Expr::Str { .. } | Expr::Var { .. } | Expr::Chn { .. } | Expr::Num { .. } => {} } } let mut substitutions = Substitutions::new(); go(self, &mut substitutions, id); substitutions } } fn gen_get(current: &mut Stmt, substitutions: Substitutions) -> Stmt { substitutions.into_iter().rfold(std::mem::take(current), |acc, next| { let (var, map_var, key) = next; let map_get_call = Expr::Var { nam: Name::new("Map/get") }; let map_get_call = Expr::Call { fun: Box::new(map_get_call), args: vec![Expr::Var { nam: map_var.clone() }, *key], kwargs: Vec::new(), }; let pat = AssignPattern::Tup(vec![AssignPattern::Var(var), AssignPattern::Var(map_var)]); Stmt::Assign { pat, val: Box::new(map_get_call), nxt: Some(Box::new(acc)) } }) } fn gen_map_var(id: &mut usize) -> Name { let name = Name::new(format!("map/get%{}", id)); *id += 1; name } ================================================ FILE: src/imp/mod.rs ================================================ pub mod gen_map_get; mod order_kwargs; pub mod parser; pub mod to_fun; use crate::fun::{Name, Num, Op, Source, Type}; use interner::global::GlobalString; #[derive(Clone, Debug)] pub enum Expr { // "*" Era, // [a-zA-Z_]+ Var { nam: Name }, // "$" [a-zA-Z_]+ Chn { nam: Name }, // [0-9_]+ Num { val: Num }, // {fun}({args},{kwargs},) Call { fun: Box, args: Vec, kwargs: Vec<(Name, Expr)> }, // "lambda" {names}* ":" {bod} Lam { names: Vec<(Name, bool)>, bod: Box }, // {lhs} {op} {rhs} Opr { op: Op, lhs: Box, rhs: Box }, // "\"" ... "\"" Str { val: GlobalString }, // "[" ... "]" Lst { els: Vec }, // "(" ... ")" Tup { els: Vec }, // "{" {els} "}" Sup { els: Vec }, // {name} "{" {kwargs} "}" Ctr { name: Name, args: Vec, kwargs: Vec<(Name, Expr)> }, // "[" {term} "for" {bind} "in" {iter} ("if" {cond})? "]" LstMap { term: Box, bind: Name, iter: Box, cond: Option> }, // "{" {entries} "}" Map { entries: Vec<(Expr, Expr)> }, // {map} "[" {key} "]" MapGet { nam: Name, key: Box }, // "![" {left} "," {right} "]" TreeNode { left: Box, right: Box }, // "!" {val} TreeLeaf { val: Box }, } #[derive(Clone, Debug)] pub struct MatchArm { pub lft: Option, pub rgt: Stmt, } #[derive(Clone, Debug, Default)] pub enum AssignPattern { // "*" #[default] Eraser, // [a-zA-Z_]+ Var(Name), // "$" [a-zA-Z_]+ Chn(Name), // "(" ... ")" Tup(Vec), // "{" ... "}" Sup(Vec), // {name} "[" {expr} "]" MapSet(Name, Expr), } #[derive(Clone, Debug)] pub enum InPlaceOp { Add, Sub, Mul, Div, And, Or, Xor, Map, } #[derive(Clone, Debug, Default)] pub enum Stmt { // {pat} = {val} ";"? {nxt} Assign { pat: AssignPattern, val: Box, nxt: Option>, }, // {var} += {val} ";"? {nxt} InPlace { op: InPlaceOp, pat: Box, val: Box, nxt: Box, }, // "if" {cond} ":" // {then} // "else" ":" // {otherwise} // {nxt}? If { cond: Box, then: Box, otherwise: Box, nxt: Option>, }, // "match" ({bind} "=")? {arg} ("with" (({bind}) | ({bind} "=" {arg}) ","?)*)? ":" // "case" {lft} ":" // {rgt} // ... // ? Match { arg: Box, bnd: Option, with_bnd: Vec>, with_arg: Vec, arms: Vec, nxt: Option>, }, // "switch" ({bind} "=")? {arg}("with" (({bind}) | ({bind} "=" {arg}) ","?)*)? ":" // "case" 0 ":" // {stmt} // ... // "case" _ ":" // {stmt} // ? Switch { arg: Box, bnd: Option, with_bnd: Vec>, with_arg: Vec, arms: Vec, nxt: Option>, }, // "bend" ({bind} ("=" {init})? ","?)* // "when" {cond} ":" // {step} // "else" ":" // {base} // {nxt}}? Bend { bnd: Vec>, arg: Vec, cond: Box, step: Box, base: Box, nxt: Option>, }, // "fold" ({bind} "=")? {arg} ("with" (({bind}) | ({bind} "=" {arg}) ","?)*)? ":" // case {lft} ":" // {rgt} // ... // {nxt}? Fold { arg: Box, bnd: Option, with_bnd: Vec>, with_arg: Vec, arms: Vec, nxt: Option>, }, // "with" {typ} ":" // "ask" {id} = {expr} ";"? // ... // ? With { typ: Name, bod: Box, nxt: Option>, }, // {pat} <- {val} ";"? {nxt} Ask { pat: AssignPattern, val: Box, nxt: Option>, }, // "return" {expr} ";"? Return { term: Box, }, // "open" {typ} ":" {var} ";"? {nxt} Open { typ: Name, var: Name, nxt: Box, }, // "use" {name} "=" {expr} ";"? {nxt} Use { nam: Name, val: Box, nxt: Box, }, // {def} {nxt} LocalDef { def: Box, nxt: Box, }, #[default] Err, } // "def" {name} "(" {params} ")" ":" {body} #[derive(Clone, Debug)] pub struct Definition { pub name: Name, pub typ: Type, pub check: bool, pub args: Vec, pub body: Stmt, pub source: Source, } impl InPlaceOp { pub fn to_lang_op(self) -> Op { match self { InPlaceOp::Add => Op::ADD, InPlaceOp::Sub => Op::SUB, InPlaceOp::Mul => Op::MUL, InPlaceOp::Div => Op::DIV, InPlaceOp::And => Op::AND, InPlaceOp::Or => Op::OR, InPlaceOp::Xor => Op::XOR, InPlaceOp::Map => unreachable!(), } } } ================================================ FILE: src/imp/order_kwargs.rs ================================================ use crate::{ fun::{parser::ParseBook, Name}, imp::{Definition, Expr, Stmt}, }; use indexmap::IndexMap; impl Definition { /// Traverses the program's definitions and adjusts the order of keyword arguments /// in call/constructor expressions to match the order specified in the function or constructor definition. pub fn order_kwargs(&mut self, book: &ParseBook) -> Result<(), String> { let use_map = &mut IndexMap::new(); self.body.order_kwargs(book, use_map).map_err(|e| format!("In function '{}':\n {}", self.name, e)) } } impl Stmt { fn order_kwargs(&mut self, book: &ParseBook, use_map: &mut IndexMap) -> Result<(), String> { match self { Stmt::LocalDef { def, nxt } => { def.order_kwargs(book)?; nxt.order_kwargs(book, use_map)?; } Stmt::Assign { val, nxt, .. } => { val.order_kwargs(book, use_map)?; if let Some(nxt) = nxt { nxt.order_kwargs(book, use_map)?; } } Stmt::Ask { val, nxt, .. } => { val.order_kwargs(book, use_map)?; if let Some(nxt) = nxt { nxt.order_kwargs(book, use_map)?; } } Stmt::InPlace { val, nxt, .. } => { val.order_kwargs(book, use_map)?; nxt.order_kwargs(book, use_map)?; } Stmt::If { cond, then, otherwise, nxt } => { cond.order_kwargs(book, use_map)?; then.order_kwargs(book, use_map)?; otherwise.order_kwargs(book, use_map)?; if let Some(nxt) = nxt { nxt.order_kwargs(book, use_map)?; } } Stmt::Match { arg, arms, nxt, .. } => { arg.order_kwargs(book, use_map)?; for arm in arms { arm.rgt.order_kwargs(book, use_map)?; } if let Some(nxt) = nxt { nxt.order_kwargs(book, use_map)?; } } Stmt::Switch { arg, arms, nxt, .. } => { arg.order_kwargs(book, use_map)?; for arm in arms { arm.order_kwargs(book, use_map)?; } if let Some(nxt) = nxt { nxt.order_kwargs(book, use_map)?; } } Stmt::Fold { arg, arms, nxt, .. } => { arg.order_kwargs(book, use_map)?; for arm in arms { arm.rgt.order_kwargs(book, use_map)?; } if let Some(nxt) = nxt { nxt.order_kwargs(book, use_map)?; } } Stmt::Bend { bnd: _, arg, cond, step, base, nxt } => { for arg in arg { arg.order_kwargs(book, use_map)?; } cond.order_kwargs(book, use_map)?; step.order_kwargs(book, use_map)?; base.order_kwargs(book, use_map)?; if let Some(nxt) = nxt { nxt.order_kwargs(book, use_map)?; } } Stmt::With { typ: _, bod, nxt } => { bod.order_kwargs(book, use_map)?; if let Some(nxt) = nxt { nxt.order_kwargs(book, use_map)?; } } Stmt::Open { typ: _, var: _, nxt } => { nxt.order_kwargs(book, use_map)?; } Stmt::Use { nam, val: bod, nxt } => { if let Expr::Var { nam: bod } = bod.as_ref() { use_map.insert(nam.clone(), bod.clone()); nxt.order_kwargs(book, use_map)?; use_map.pop(); } else { bod.order_kwargs(book, use_map)?; nxt.order_kwargs(book, use_map)?; } } Stmt::Return { term } => term.order_kwargs(book, use_map)?, Stmt::Err => {} } Ok(()) } } impl Expr { fn order_kwargs(&mut self, book: &ParseBook, use_map: &mut IndexMap) -> Result<(), String> { match self { // Named arguments are only allowed when directly calling a named function. Expr::Call { fun, args, kwargs } => { if !kwargs.is_empty() { if let Expr::Var { nam } = fun.as_ref() { if let Some(names) = get_args_def_or_ctr(nam, book, use_map) { go_order_kwargs(&names, args, kwargs)?; } else { return Err(format!( "Named args are only allowed when calling a named function, not when calling variable '{nam}'." )); } } else { // TODO: Print expression return Err( "Named args are only allowed when calling a named function, not when calling an expression." .to_string(), ); } } fun.order_kwargs(book, use_map)?; for arg in args { arg.order_kwargs(book, use_map)?; } for (_, arg) in kwargs { arg.order_kwargs(book, use_map)?; } } Expr::Lam { bod, .. } => bod.order_kwargs(book, use_map)?, Expr::Opr { lhs, rhs, .. } => { lhs.order_kwargs(book, use_map)?; rhs.order_kwargs(book, use_map)?; } Expr::Lst { els } | Expr::Tup { els } | Expr::Sup { els } => { for el in els { el.order_kwargs(book, use_map)?; } } Expr::LstMap { term, iter, cond, .. } => { term.order_kwargs(book, use_map)?; iter.order_kwargs(book, use_map)?; if let Some(cond) = cond { cond.order_kwargs(book, use_map)?; } } Expr::Ctr { name, args, kwargs } => match get_args_def_or_ctr(name, book, use_map) { Some(names) => { go_order_kwargs(&names, args, kwargs)?; for arg in args { arg.order_kwargs(book, use_map)?; } } _ => return Err(format!("Constructor '{name}' not found.")), }, Expr::Map { entries } => { for entry in entries { entry.1.order_kwargs(book, use_map)?; } } Expr::MapGet { nam: _, key } => { key.order_kwargs(book, use_map)?; } Expr::TreeNode { left, right } => { left.order_kwargs(book, use_map)?; right.order_kwargs(book, use_map)?; } Expr::TreeLeaf { val } => { val.order_kwargs(book, use_map)?; } Expr::Era | Expr::Var { .. } | Expr::Chn { .. } | Expr::Num { .. } | Expr::Str { .. } => {} } Ok(()) } } fn go_order_kwargs( names: &[Name], args: &mut Vec, kwargs: &mut Vec<(Name, Expr)>, ) -> Result<(), String> { if args.len() + kwargs.len() != names.len() { return Err( "Named args are only allowed when calling a function with the exact number of arguments.".to_string(), ); } let mut kwargs: IndexMap = IndexMap::from_iter(kwargs.drain(..)); let remaining_names = &names[args.len()..]; for name in remaining_names { if let Some(arg) = kwargs.shift_remove(name) { args.push(arg); } else { return Err(format!("Named arg '{name}' is missing.")); } } if let Some(name) = kwargs.keys().next() { return Err(format!("Unexpected named arg in function call {}.", name)); } Ok(()) } fn get_args_def_or_ctr(name: &Name, book: &ParseBook, use_map: &IndexMap) -> Option> { let name = use_map.get(name).unwrap_or(name); #[allow(clippy::manual_map)] if let Some(adt_nam) = book.ctrs.get(name) { Some(book.adts[adt_nam].ctrs[name].fields.iter().map(|f| f.nam.clone()).collect()) } else if let Some(def) = book.fun_defs.get(name) { Some(def.rules[0].pats.iter().flat_map(|p| p.binds().flatten().cloned()).collect()) } else { None } } ================================================ FILE: src/imp/parser.rs ================================================ use crate::{ fun::{ parser::{is_num_char, make_ctr_type, make_fn_type, Indent, ParseResult, ParserCommons}, Adt, AdtCtr, CtrField, HvmDefinition, Name, Num, Op, Source, SourceKind, Type, STRINGS, }, imp::{AssignPattern, Definition, Expr, InPlaceOp, MatchArm, Stmt}, maybe_grow, }; use TSPL::Parser; pub struct ImpParser<'i> { pub file: Name, pub input: &'i str, pub index: usize, pub builtin: bool, } impl<'a> ImpParser<'a> { pub fn new(file: Name, input: &'a str, builtin: bool) -> Self { Self { file, input, index: 0, builtin } } pub fn parse_function_def(&mut self, indent: Indent) -> ParseResult<(Definition, Indent)> { // def name(arg1: type1, arg2: type2, ...) -> type: // body if indent != Indent::Val(0) { let msg = "Indentation error. Functions defined with 'def' must be at the start of the line."; let idx = *self.index(); return self.with_ctx(Err(msg), idx..idx + 1); } // TODO: checked vs unchecked functions let (mut def, nxt_indent) = self.parse_def_aux(indent)?; def.source.kind = if self.builtin { SourceKind::Builtin } else { SourceKind::User }; Ok((def, nxt_indent)) } pub fn parse_type_def(&mut self, mut indent: Indent) -> ParseResult<(Adt, Indent)> { if indent != Indent::Val(0) { let msg = "Indentation error. Types defined with 'type' must be at the start of the line."; let idx = *self.index(); return self.with_ctx(Err(msg), idx..idx + 1); } let ini_idx = *self.index(); self.parse_keyword("type")?; self.skip_trivia_inline()?; let type_name = self.parse_restricted_name("datatype")?; self.skip_trivia_inline()?; let type_vars = if self.try_consume_exactly("(") { self.list_like(|p| p.parse_var_name(), "", ")", ",", true, 0)? } else { vec![] }; self.skip_trivia_inline()?; self.consume_exactly(":")?; self.consume_new_line()?; indent.enter_level(); self.consume_indent_exactly(indent)?; let mut ctrs = Vec::new(); let mut nxt_indent = indent; while nxt_indent == indent { ctrs.push(self.parse_type_def_variant(&type_name, &type_vars)?); if !self.is_eof() { self.consume_new_line()?; } nxt_indent = self.consume_indent_at_most(indent)?; } indent.exit_level(); let ctrs = ctrs.into_iter().map(|ctr| (ctr.name.clone(), ctr)).collect(); let source = Source::from_file_span(&self.file, self.input, ini_idx..self.index, self.builtin); let adt = Adt { name: type_name, vars: type_vars, ctrs, source }; Ok((adt, nxt_indent)) } pub fn parse_object(&mut self, indent: Indent) -> ParseResult<(Adt, Indent)> { // object Pair(a, b) { fst: a, snd: b } if indent != Indent::Val(0) { let msg = "Indentation error. Types defined with 'object' must be at the start of the line."; let idx = *self.index(); return self.with_ctx(Err(msg), idx..idx + 1); } let ini_idx = *self.index(); self.parse_keyword("object")?; self.skip_trivia_inline()?; let name = self.parse_top_level_name()?; self.skip_trivia_inline()?; let type_vars = if self.starts_with("(") { self.list_like(|p| p.parse_var_name(), "(", ")", ",", true, 0)? } else { vec![] }; self.skip_trivia_inline()?; let fields = if self.starts_with("{") { self.list_like(|p| p.parse_variant_field(), "{", "}", ",", true, 0)? } else { vec![] }; let field_types = fields.iter().map(|f| f.typ.clone()).collect::>(); let end_idx = *self.index(); self.check_repeated_ctr_fields(&fields, &name, ini_idx..end_idx)?; if !self.is_eof() { self.consume_new_line()?; } let nxt_indent = self.advance_newlines()?; let typ = make_ctr_type(name.clone(), &field_types, &type_vars); let ctr = AdtCtr { name: name.clone(), typ, fields }; let ctrs = [(name.clone(), ctr)].into_iter().collect(); let source = Source::from_file_span(&self.file, self.input, ini_idx..end_idx, self.builtin); let adt = Adt { name, vars: type_vars, ctrs, source }; Ok((adt, nxt_indent)) } pub fn parse_hvm(&mut self) -> ParseResult<(HvmDefinition, Indent)> { let ini_idx = *self.index(); self.parse_keyword("hvm")?; self.skip_trivia_inline()?; let name = self.parse_var_name()?; self.skip_trivia_inline()?; let typ = self.parse_return_type()?.unwrap_or(Type::Any); let typ = make_fn_type(vec![], typ); self.skip_trivia_inline()?; self.consume_exactly(":")?; self.consume_new_line()?; // TODO: This will have the wrong index let net_idx = *self.index(); let mut p = hvm::ast::CoreParser::new(&self.input[net_idx..]); let body = p.parse_net()?; *self.index() = net_idx + *p.index(); let source = Source::from_file_span(&self.file, self.input, ini_idx..self.index, self.builtin); let def = HvmDefinition { name: name.clone(), typ, body, source }; let nxt_indent = self.advance_newlines()?; Ok((def, nxt_indent)) } fn parse_type_def_variant(&mut self, type_name: &Name, type_vars: &[Name]) -> ParseResult { let ini_idx = *self.index(); let name = self.parse_top_level_name()?; let name = Name::new(format!("{type_name}/{name}")); self.skip_trivia_inline()?; let fields = if self.try_consume_exactly("{") { self.list_like(|p| p.parse_variant_field(), "", "}", ",", true, 0)? } else { vec![] }; let field_types = fields.iter().map(|f| f.typ.clone()).collect::>(); let end_idx = *self.index(); self.check_repeated_ctr_fields(&fields, &name, ini_idx..end_idx)?; let typ = make_ctr_type(type_name.clone(), &field_types, type_vars); Ok(AdtCtr { name, typ, fields }) } fn parse_variant_field(&mut self) -> ParseResult { let rec = self.try_consume_exactly("~"); self.skip_trivia_inline()?; let nam = self.parse_var_name()?; self.skip_trivia_inline()?; let typ = if self.try_consume_exactly(":") { self.parse_type_expr()? } else { Type::Any }; Ok(CtrField { nam, typ, rec }) } fn parse_primary_expr(&mut self, inline: bool) -> ParseResult { if inline { self.skip_trivia_inline()?; } else { self.skip_trivia(); } if self.try_parse_keyword("lambda") | self.try_consume_exactly("λ") { fn parse_lam_var(p: &mut ImpParser) -> ParseResult<(Name, bool)> { if p.starts_with("$") { p.advance_one(); Ok((p.parse_var_name()?, true)) } else { Ok((p.parse_var_name()?, false)) } } let names = self.list_like(|p| parse_lam_var(p), "", ":", ",", false, 1)?; let bod = self.parse_expr(inline, false)?; Ok(Expr::Lam { names, bod: Box::new(bod) }) } else if self.starts_with("(") { self.advance_one(); let expr = self.parse_expr(inline, true)?; self.consume(")")?; Ok(expr) } else if self.starts_with("{") { // Map or Sup self.parse_map_or_sup() } else if self.starts_with("[") { // List or Comprehension self.parse_list_or_comprehension() } else if self.starts_with("![") { // Tree Node self.parse_tree_node() } else if self.starts_with("!") { // Tree Leaf self.parse_tree_leaf(inline) } else if self.starts_with("`") { // Symbol Ok(Expr::Num { val: Num::U24(self.parse_quoted_symbol()?) }) } else if self.starts_with("\"") { // String Ok(Expr::Str { val: STRINGS.get(self.parse_quoted_string()?) }) } else if self.starts_with("'") { // Char Ok(Expr::Num { val: Num::U24(self.parse_quoted_char()? as u32 & 0x00ff_ffff) }) } else if self.starts_with("$") { // Unscoped var self.advance_one(); Ok(Expr::Chn { nam: self.parse_var_name()? }) } else if self.starts_with("*") { // Era self.advance_one(); Ok(Expr::Era) } else if let Some(c) = self.peek_one() { if is_num_char(c) { // Number Ok(Expr::Num { val: self.parse_number()? }) } else { // Var let nam = self.labelled(|p| p.parse_var_name(), "expression")?; Ok(Expr::Var { nam }) } } else { self.expected("expression")? } } fn call_or_postfix(&mut self, inline: bool) -> ParseResult { let ini_idx = *self.index(); let base = self.parse_primary_expr(inline)?; if inline { self.skip_trivia_inline()?; } else { self.skip_trivia(); } // call if self.starts_with("(") { self.advance_one(); let mut args = Vec::new(); let mut kwargs = Vec::new(); let mut must_be_named = false; while !self.starts_with(")") { let ini_idx = *self.index(); let (bnd, arg) = self.parse_named_arg()?; let end_idx = *self.index(); if let Some(bnd) = bnd { must_be_named = true; kwargs.push((bnd, arg)); } else if must_be_named { let msg = "Positional arguments are not allowed to go after named arguments.".to_string(); return self.with_ctx(Err(msg), ini_idx..end_idx); } else { args.push(arg); } if self.starts_with(",") { self.consume(",")?; } else { break; } } self.consume(")")?; if args.is_empty() && kwargs.is_empty() { return Ok(base); } else { return Ok(Expr::Call { fun: Box::new(base), args, kwargs }); } } // map get if self.starts_with("[") { if let Expr::Var { nam } = base { self.advance_one(); let key = self.parse_expr(inline, false)?; self.consume("]")?; return Ok(Expr::MapGet { nam, key: Box::new(key) }); } else { let end_idx = *self.index(); return self.expected_spanned("Map variable name", ini_idx..end_idx); } } // ctr if self.starts_with("{") { if let Expr::Var { nam } = base { let kwargs = self.list_like(|p| p.data_kwarg(), "{", "}", ",", true, 0)?; return Ok(Expr::Ctr { name: nam, args: Vec::new(), kwargs }); } else { let end_idx = *self.index(); return self.expected_spanned("Constructor name", ini_idx..end_idx); } } // no postfix Ok(base) } fn parse_map_or_sup(&mut self) -> ParseResult { self.advance_one(); // Empty map if self.try_consume("}") { return Ok(Expr::Map { entries: vec![] }); } let head = self.parse_expr(false, false)?; self.skip_trivia(); if self.try_consume(",") { self.parse_sup(head) } else if self.try_consume(":") { self.parse_map_init(head) } else { self.expected("',' or ':'") } } fn parse_map_init(&mut self, head: Expr) -> ParseResult { let mut entries = Vec::new(); let val = self.parse_expr(false, false)?; entries.push((head, val)); self.skip_trivia(); if !self.starts_with("}") { self.consume(",")?; } let tail = self.list_like(|p| p.parse_map_entry(), "", "}", ",", true, 0)?; entries.extend(tail); Ok(Expr::Map { entries }) } fn parse_sup(&mut self, head: Expr) -> ParseResult { let mut els = vec![head]; let tail = self.list_like(|p| p.parse_expr(false, false), "", "}", ",", true, 1)?; els.extend(tail); Ok(Expr::Sup { els }) } fn parse_tree_node(&mut self) -> ParseResult { self.advance_one(); self.advance_one(); let left = self.parse_expr(false, false)?; self.consume(",")?; let right = self.parse_expr(false, false)?; self.consume("]")?; Ok(Expr::TreeNode { left: Box::new(left), right: Box::new(right) }) } fn parse_tree_leaf(&mut self, inline: bool) -> ParseResult { self.advance_one(); let val = self.parse_expr(inline, false)?; Ok(Expr::TreeLeaf { val: Box::new(val) }) } fn data_kwarg(&mut self) -> ParseResult<(Name, Expr)> { self.skip_trivia(); let nam = self.parse_var_name()?; self.consume(":")?; let expr = self.parse_expr(false, false)?; Ok((nam, expr)) } fn parse_map_entry(&mut self) -> ParseResult<(Expr, Expr)> { let key = self.parse_expr(false, false)?; self.consume(":")?; let val = self.parse_expr(false, false)?; Ok((key, val)) } fn parse_list_or_comprehension(&mut self) -> ParseResult { self.consume_exactly("[")?; // Empty list self.skip_trivia(); if self.try_consume_exactly("]") { return Ok(Expr::Lst { els: vec![] }); } let head = self.parse_expr(false, false)?; self.skip_trivia(); if self.try_parse_keyword("for") { // Comprehension self.skip_trivia(); let bind = self.parse_var_name()?; self.skip_trivia(); self.parse_keyword("in")?; let iter = self.parse_expr(false, false)?; let mut cond = None; self.skip_trivia(); if self.try_parse_keyword("if") { cond = Some(Box::new(self.parse_expr(false, false)?)); } self.consume("]")?; Ok(Expr::LstMap { term: Box::new(head), bind, iter: Box::new(iter), cond }) } else { // List let mut head = vec![head]; self.skip_trivia(); if !self.starts_with("]") { self.consume(",")?; } let tail = self.list_like(|p| p.parse_expr(false, false), "", "]", ",", true, 0)?; head.extend(tail); Ok(Expr::Lst { els: head }) } } /// "λ" ( ","?)+ ":" /// | "open" ":" /// | fn parse_expr(&mut self, inline: bool, tup: bool) -> ParseResult { if inline { self.skip_trivia_inline()?; } else { self.skip_trivia(); } let base = self.parse_infix_expr(0, inline)?; if !tup { return Ok(base); } if inline { self.skip_trivia_inline()?; } else { self.skip_trivia(); } if self.starts_with(",") { let mut els = vec![base]; loop { if self.starts_with(",") { self.advance_one(); els.push(self.parse_expr(inline, false)?); if self.starts_with("\n") { break; } if inline { self.skip_trivia_inline()?; } else { self.skip_trivia(); } } else { break; } } Ok(Expr::Tup { els }) } else { Ok(base) } } /// Named argument of a function call. fn parse_named_arg(&mut self) -> ParseResult<(Option, Expr)> { let arg = self.parse_expr(false, false)?; if self.try_consume("=") { if let Expr::Var { nam } = arg { let bind = Some(nam); let arg = self.parse_expr(false, false)?; Ok((bind, arg)) } else { let msg = "Unexpected '=' in unnamed argument.".to_string(); let idx = *self.index(); self.with_ctx(Err(msg), idx..idx + 1) } } else { Ok((None, arg)) } } /// Infix expression. /// ( )? fn parse_infix_expr(&mut self, prec: usize, inline: bool) -> ParseResult { maybe_grow(|| { if inline { self.skip_trivia_inline()?; } else { self.skip_trivia(); } if prec > Op::max_precedence() { return self.call_or_postfix(inline); } let mut lhs = self.parse_infix_expr(prec + 1, inline)?; if inline { self.skip_trivia_inline()?; } else { self.skip_trivia(); } while let Some(op) = self.peek_oper() { if op.precedence() == prec { self.try_parse_oper().unwrap(); let rhs = self.parse_infix_expr(prec + 1, inline)?; lhs = Expr::Opr { op, lhs: Box::new(lhs), rhs: Box::new(rhs) }; self.skip_trivia_inline()?; } else { break; } } Ok(lhs) }) } fn consume_indent_at_most(&mut self, expected: Indent) -> ParseResult { let got = self.advance_newlines()?; match (expected, got) { (_, Indent::Eof) => Ok(Indent::Eof), (Indent::Val(expected), Indent::Val(got)) if got <= expected => Ok(Indent::Val(got)), (expected, got) => self.expected_indent(expected, got), } } fn consume_indent_exactly(&mut self, expected: Indent) -> ParseResult<()> { let got = self.advance_newlines()?; match (expected, got) { (Indent::Eof, Indent::Eof) => Ok(()), (Indent::Val(expected), Indent::Val(got)) if got == expected => Ok(()), (expected, got) => self.expected_indent(expected, got), } } /// Parses a statement and returns the indentation of the next statement. fn parse_statement(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, Indent)> { maybe_grow(|| { if self.starts_with_keyword("return") { self.parse_return() } else if self.starts_with_keyword("def") { self.parse_local_def(indent) } else if self.starts_with_keyword("if") { self.parse_if(indent) } else if self.starts_with_keyword("match") { self.parse_match(indent) } else if self.starts_with_keyword("switch") { self.parse_switch(indent) } else if self.starts_with_keyword("fold") { self.parse_fold(indent) } else if self.starts_with_keyword("bend") { self.parse_bend(indent) } else if self.starts_with_keyword("with") { self.parse_with(indent) } else if self.starts_with_keyword("open") { self.parse_open(indent) } else if self.starts_with_keyword("use") { self.parse_use(indent) } else { self.parse_assign(indent) } }) } /// Assignments, monadic bind operations and in-place operations. /// "=" ";"? /// | "<-" ";"? /// fn parse_assign(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, Indent)> { let ini_idx = *self.index(); let pat = self.parse_assign_pattern()?; let end_idx = *self.index(); self.skip_trivia_inline()?; // Assignment if self.starts_with("=") { self.advance_one(); let val = self.parse_expr(true, true)?; self.skip_trivia_inline()?; self.try_consume_exactly(";"); if !self.is_eof() { self.consume_new_line()?; } let nxt_indent = self.advance_newlines()?; if nxt_indent == *indent { let (nxt, nxt_indent) = self.parse_statement(indent)?; let stmt = Stmt::Assign { pat, val: Box::new(val), nxt: Some(Box::new(nxt)) }; return Ok((stmt, nxt_indent)); } else { let stmt = Stmt::Assign { pat, val: Box::new(val), nxt: None }; return Ok((stmt, nxt_indent)); } } // Ask if self.starts_with("<-") { self.consume("<-")?; let val = self.parse_expr(true, true)?; self.skip_trivia_inline()?; self.try_consume_exactly(";"); let nxt_indent = self.advance_newlines()?; if nxt_indent == *indent { let (nxt, nxt_indent) = self.parse_statement(indent)?; let stmt = Stmt::Ask { pat, val: Box::new(val), nxt: Some(Box::new(nxt)) }; return Ok((stmt, nxt_indent)); } else { let stmt = Stmt::Ask { pat, val: Box::new(val), nxt: None }; return Ok((stmt, nxt_indent)); } } // In-place match &pat { AssignPattern::Var(..) => {} AssignPattern::MapSet(..) => {} _ => self.expected_spanned("Var or Map accessor", ini_idx..end_idx)?, } if let Some(op) = self.parse_in_place_op()? { let val = self.parse_expr(true, false)?; self.skip_trivia_inline()?; self.try_consume_exactly(";"); self.consume_indent_exactly(*indent)?; let (nxt, nxt_indent) = self.parse_statement(indent)?; let stmt = Stmt::InPlace { op, pat: Box::new(pat), val: Box::new(val), nxt: Box::new(nxt) }; return Ok((stmt, nxt_indent)); } self.expected_spanned("statement", ini_idx..end_idx) } fn parse_in_place_op(&mut self) -> ParseResult> { self.skip_trivia_inline()?; let op = if self.starts_with("+=") { self.consume("+=")?; Some(InPlaceOp::Add) } else if self.starts_with("-=") { self.consume("-=")?; Some(InPlaceOp::Sub) } else if self.starts_with("*=") { self.consume("*=")?; Some(InPlaceOp::Mul) } else if self.starts_with("/=") { self.consume("/=")?; Some(InPlaceOp::Div) } else if self.starts_with("&=") { self.consume("&=")?; Some(InPlaceOp::And) } else if self.starts_with("|=") { self.consume("|=")?; Some(InPlaceOp::Or) } else if self.starts_with("^=") { self.consume("^=")?; Some(InPlaceOp::Xor) } else if self.starts_with("@=") { self.consume("@=")?; Some(InPlaceOp::Map) } else { None }; Ok(op) } fn parse_return(&mut self) -> ParseResult<(Stmt, Indent)> { self.parse_keyword("return")?; let term = self.parse_expr(true, true)?; self.skip_trivia_inline()?; self.try_consume_exactly(";"); if !self.is_eof() { self.consume_new_line()?; } let indent = self.advance_newlines()?; Ok((Stmt::Return { term: Box::new(term) }, indent)) } fn parse_if(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, Indent)> { self.parse_keyword("if")?; self.skip_trivia_inline()?; let cond = self.parse_expr(true, true)?; self.skip_trivia_inline()?; self.consume_exactly(":")?; indent.enter_level(); self.consume_indent_exactly(*indent)?; let (then, nxt_indent) = self.parse_statement(indent)?; indent.exit_level(); if nxt_indent != *indent { return self .expected_indent(*indent, nxt_indent) .or(self.expected_spanned("'else' or 'elif'", self.index..self.index + 1)); } let mut elifs = Vec::new(); while self.try_parse_keyword("elif") { let cond = self.parse_expr(true, false)?; self.skip_trivia_inline()?; self.consume_exactly(":")?; indent.enter_level(); self.consume_indent_exactly(*indent)?; let (then, nxt_indent) = self.parse_statement(indent)?; indent.exit_level(); if nxt_indent != *indent { return self .expected_indent(*indent, nxt_indent) .or(self.expected_spanned("'else' or 'elif'", self.index..self.index + 1)); } elifs.push((cond, then)); } self.parse_keyword("else")?; self.skip_trivia_inline()?; self.consume_exactly(":")?; indent.enter_level(); self.consume_indent_exactly(*indent)?; let (otherwise, nxt_indent) = self.parse_statement(indent)?; let otherwise = elifs.into_iter().rfold(otherwise, |acc, (cond, then)| Stmt::If { cond: Box::new(cond), then: Box::new(then), otherwise: Box::new(acc), nxt: None, }); indent.exit_level(); if nxt_indent == *indent { let (nxt, nxt_indent) = self.parse_statement(indent)?; let stmt = Stmt::If { cond: Box::new(cond), then: Box::new(then), otherwise: Box::new(otherwise), nxt: Some(Box::new(nxt)), }; Ok((stmt, nxt_indent)) } else { let stmt = Stmt::If { cond: Box::new(cond), then: Box::new(then), otherwise: Box::new(otherwise), nxt: None }; Ok((stmt, nxt_indent)) } } fn parse_match(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, Indent)> { self.parse_keyword("match")?; self.skip_trivia_inline()?; let (bnd, arg) = self.parse_match_arg()?; self.skip_trivia_inline()?; let (with_bnd, with_arg) = self.parse_with_clause()?; self.consume_new_line()?; indent.enter_level(); self.consume_indent_exactly(*indent).or(self.expected_spanned("'case'", self.index..self.index + 1))?; let (case, mut nxt_indent) = self.parse_match_case(indent)?; let mut arms = vec![case]; while nxt_indent == *indent { let (case, nxt_indent_) = self.parse_match_case(indent)?; nxt_indent = nxt_indent_; arms.push(case); } indent.exit_level(); if nxt_indent == *indent { let (nxt, nxt_indent) = self.parse_statement(indent)?; let stmt = Stmt::Match { arg: Box::new(arg), bnd, with_bnd, with_arg, arms, nxt: Some(Box::new(nxt)) }; Ok((stmt, nxt_indent)) } else { let stmt = Stmt::Match { arg: Box::new(arg), bnd, with_bnd, with_arg, arms, nxt: None }; Ok((stmt, nxt_indent)) } } fn parse_match_arg(&mut self) -> ParseResult<(Option, Expr)> { let ini_idx = *self.index(); let arg = self.parse_expr(true, false)?; let end_idx = *self.index(); self.skip_trivia_inline()?; match (arg, self.starts_with("=")) { (Expr::Var { nam }, true) => { self.advance_one(); Ok((Some(nam), self.parse_expr(true, false)?)) } (_, true) => self.expected_spanned("argument name", ini_idx..end_idx), (Expr::Var { nam }, false) => Ok((Some(nam.clone()), Expr::Var { nam })), (arg, false) => Ok((Some(Name::new("%arg")), arg)), } } fn parse_with_clause(&mut self) -> ParseResult<(Vec>, Vec)> { self.skip_trivia_inline()?; let res = if self.try_parse_keyword("with") { self.list_like(|p| p.parse_with_arg(), "", ":", ",", true, 1)?.into_iter().unzip() } else { self.consume_exactly(":")?; (vec![], vec![]) }; Ok(res) } fn parse_with_arg(&mut self) -> ParseResult<(Option, Expr)> { let bind = self.parse_var_name()?; self.skip_trivia_inline()?; if self.try_consume("=") { let arg = self.parse_expr(false, false)?; Ok((Some(bind), arg)) } else { Ok((Some(bind.clone()), Expr::Var { nam: bind })) } } fn parse_match_case(&mut self, indent: &mut Indent) -> ParseResult<(MatchArm, Indent)> { self.parse_keyword("case")?; self.skip_trivia_inline()?; let pat = if self.try_consume_exactly("_") { None } else { let nam = self.labelled(|p| p.parse_var_name(), "name or '_'")?; Some(nam) }; self.skip_trivia_inline()?; self.consume_exactly(":")?; self.consume_new_line()?; indent.enter_level(); self.consume_indent_exactly(*indent)?; let (body, nxt_indent) = self.parse_statement(indent)?; indent.exit_level(); let stmt = MatchArm { lft: pat, rgt: body }; Ok((stmt, nxt_indent)) } fn parse_switch(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, Indent)> { self.parse_keyword("switch")?; self.skip_trivia_inline()?; let (bnd, arg) = self.parse_match_arg()?; self.skip_trivia_inline()?; let (with_bnd, with_arg) = self.parse_with_clause()?; indent.enter_level(); self.consume_indent_exactly(*indent)?; let ini_idx = *self.index(); let (fst_case, fst_stmt, mut nxt_indent) = self.parse_switch_case(indent)?; let end_idx = *self.index(); if fst_case != Some(0) { return self.expected_spanned("case 0", ini_idx..end_idx); } let mut arms = vec![fst_stmt]; let mut should_continue = fst_case == Some(0); let mut expected_num = 1; while should_continue { if nxt_indent != *indent { return self .expected_indent(*indent, nxt_indent) .or(self.expected_spanned("'case'", self.index..self.index + 1)); } let (case, stmt, nxt_indent_) = self.parse_switch_case(indent)?; nxt_indent = nxt_indent_; if let Some(case) = case { if case != expected_num { return self.expected(&format!("case {}", expected_num)); } should_continue = true; arms.push(stmt); expected_num += 1; } else { should_continue = false; arms.push(stmt); } } indent.exit_level(); if nxt_indent == *indent { let (nxt, nxt_indent) = self.parse_statement(indent)?; let stmt = Stmt::Switch { arg: Box::new(arg), bnd, with_bnd, with_arg, arms, nxt: Some(Box::new(nxt)) }; Ok((stmt, nxt_indent)) } else { let stmt = Stmt::Switch { arg: Box::new(arg), bnd, with_bnd, with_arg, arms, nxt: None }; Ok((stmt, nxt_indent)) } } fn parse_switch_case(&mut self, indent: &mut Indent) -> ParseResult<(Option, Stmt, Indent)> { self.parse_keyword("case")?; self.skip_trivia_inline()?; let case = if let Some(c) = self.peek_one() { match c { '_' => { self.advance_one(); None } c if c.is_ascii_digit() => Some(self.parse_u32()?), _ => return self.expected("number or '_'"), } } else { return self.expected("number or '_'")?; }; self.skip_trivia_inline()?; self.consume_exactly(":")?; self.consume_new_line()?; indent.enter_level(); self.consume_indent_exactly(*indent)?; let (stmt, nxt_indent) = self.parse_statement(indent)?; indent.exit_level(); Ok((case, stmt, nxt_indent)) } /// "fold" ("=" )? ":" /// "case" ":" /// /// ... fn parse_fold(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, Indent)> { self.parse_keyword("fold")?; self.skip_trivia_inline()?; // Actually identical to match, except the return let (bind, arg) = self.parse_match_arg()?; self.skip_trivia_inline()?; let (with_bnd, with_arg) = self.parse_with_clause()?; self.consume_new_line()?; indent.enter_level(); self.consume_indent_exactly(*indent).or(self.expected_spanned("'case'", self.index..self.index + 1))?; let (case, mut nxt_indent) = self.parse_match_case(indent)?; let mut arms = vec![case]; while nxt_indent == *indent { let (case, nxt_indent_) = self.parse_match_case(indent)?; nxt_indent = nxt_indent_; arms.push(case); } indent.exit_level(); if nxt_indent == *indent { let (nxt, nxt_indent) = self.parse_statement(indent)?; let stmt = Stmt::Fold { arg: Box::new(arg), bnd: bind, arms, with_bnd, with_arg, nxt: Some(Box::new(nxt)) }; Ok((stmt, nxt_indent)) } else { let stmt = Stmt::Fold { arg: Box::new(arg), bnd: bind, arms, with_bnd, with_arg, nxt: None }; Ok((stmt, nxt_indent)) } } /// "bend" ( "=" ","?)* ":" /// "when" ":" /// /// "else" ":" /// fn parse_bend(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, Indent)> { self.parse_keyword("bend")?; self.skip_trivia_inline()?; let args = self.list_like(|p| p.parse_match_arg(), "", ":", ",", true, 1)?; let (bind, init) = args.into_iter().unzip(); self.consume_new_line()?; indent.enter_level(); self.consume_indent_exactly(*indent).or(self.expected_spanned("'when'", self.index..self.index + 1))?; self.parse_keyword("when")?; self.skip_trivia_inline()?; let cond = self.parse_expr(true, true)?; self.skip_trivia_inline()?; self.consume_exactly(":")?; self.consume_new_line()?; indent.enter_level(); self.consume_indent_exactly(*indent)?; let (step, nxt_indent) = self.parse_statement(indent)?; indent.exit_level(); if nxt_indent != *indent { return self .expected_indent(*indent, nxt_indent) .or(self.expected_spanned("'else'", self.index..self.index + 1)); } self.parse_keyword("else")?; self.skip_trivia_inline()?; self.consume_exactly(":")?; self.consume_new_line()?; indent.enter_level(); self.consume_indent_exactly(*indent)?; let (base, nxt_indent) = self.parse_statement(indent)?; indent.exit_level(); indent.exit_level(); if nxt_indent == *indent { let (nxt, nxt_indent) = self.parse_statement(indent)?; let stmt = Stmt::Bend { bnd: bind, arg: init, cond: Box::new(cond), step: Box::new(step), base: Box::new(base), nxt: Some(Box::new(nxt)), }; Ok((stmt, nxt_indent)) } else { let stmt = Stmt::Bend { bnd: bind, arg: init, cond: Box::new(cond), step: Box::new(step), base: Box::new(base), nxt: None, }; Ok((stmt, nxt_indent)) } } /// "with" ":" /// /// ? fn parse_with(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, Indent)> { self.parse_keyword("with")?; self.skip_trivia_inline()?; let typ = self.parse_var_name()?; self.skip_trivia_inline()?; self.consume_exactly(":")?; self.consume_new_line()?; indent.enter_level(); self.consume_indent_exactly(*indent)?; let (bod, nxt_indent) = self.parse_statement(indent)?; indent.exit_level(); if nxt_indent == *indent { let (nxt, nxt_indent) = self.parse_statement(indent)?; let stmt = Stmt::With { typ, bod: Box::new(bod), nxt: Some(Box::new(nxt)) }; Ok((stmt, nxt_indent)) } else { let stmt = Stmt::With { typ, bod: Box::new(bod), nxt: None }; Ok((stmt, nxt_indent)) } } /// /// | "[" "]" /// | ("," )* fn parse_assign_pattern(&mut self) -> ParseResult { let head_ini = *self.index(); let head = self.parse_primary_assign_pattern()?; let head_end = *self.index(); self.skip_trivia_inline()?; if self.starts_with("[") { // TODO: allow patterns like `x[a][b]` self.advance_one(); let key = self.parse_expr(false, false)?; self.consume("]")?; if let AssignPattern::Var(var) = head { Ok(AssignPattern::MapSet(var, key)) } else { self.with_ctx(Err("Expected a variable pattern"), head_ini..head_end) } } else if self.starts_with(",") { let mut els = vec![head]; while self.try_consume(",") { self.skip_trivia_inline()?; els.push(self.parse_primary_assign_pattern()?); } Ok(AssignPattern::Tup(els)) } else { Ok(head) } } /// "*" /// | "{" ("," )+ "}" /// | "$" /// | "(" ")" /// | fn parse_primary_assign_pattern(&mut self) -> ParseResult { if self.starts_with("*") { self.advance_one(); Ok(AssignPattern::Eraser) } else if self.starts_with("{") { let binds = self.list_like(|p| p.parse_primary_assign_pattern(), "{", "}", ",", true, 2)?; Ok(AssignPattern::Sup(binds)) } else if self.starts_with("$") { self.advance_one(); self.skip_trivia_inline()?; let nam = self.parse_var_name()?; Ok(AssignPattern::Chn(nam)) } else if self.starts_with("(") { self.advance_one(); let assign = self.parse_assign_pattern()?; self.consume(")")?; Ok(assign) } else { Ok(AssignPattern::Var(self.parse_var_name()?)) } } /// "open" {typ} ":" {var} ";"? {nxt} fn parse_open(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, Indent)> { self.parse_keyword("open")?; self.skip_trivia_inline()?; let typ = self.labelled(|p| p.parse_var_name(), "type name")?; self.skip_trivia_inline()?; self.consume_exactly(":")?; self.skip_trivia_inline()?; let var = self.labelled(|p| p.parse_var_name(), "variable name")?; self.skip_trivia_inline()?; self.try_consume_exactly(";"); self.consume_new_line()?; self.consume_indent_exactly(*indent)?; let (nxt, nxt_indent) = self.parse_statement(indent)?; let stmt = Stmt::Open { typ, var, nxt: Box::new(nxt) }; Ok((stmt, nxt_indent)) } fn parse_use(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, Indent)> { self.parse_keyword("use")?; self.skip_trivia_inline()?; let nam = self.parse_var_name()?; self.skip_trivia_inline()?; self.consume_exactly("=")?; self.skip_trivia_inline()?; let bod = self.parse_expr(true, true)?; self.skip_trivia_inline()?; self.try_consume_exactly(";"); self.consume_new_line()?; self.consume_indent_exactly(*indent)?; let (nxt, nxt_indent) = self.parse_statement(indent)?; let stmt = Stmt::Use { nam, val: Box::new(bod), nxt: Box::new(nxt) }; Ok((stmt, nxt_indent)) } fn parse_local_def(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, Indent)> { // TODO: checked vs unchecked functions let (mut def, mut nxt_indent) = self.parse_def_aux(*indent)?; def.source.kind = if self.builtin { SourceKind::Builtin } else { SourceKind::Generated }; let (nxt, nxt_indent) = self.parse_statement(&mut nxt_indent)?; let stmt = Stmt::LocalDef { def: Box::new(def), nxt: Box::new(nxt) }; Ok((stmt, nxt_indent)) } /// Parses a type expression, returning the type and the type variables. fn parse_type_expr(&mut self) -> ParseResult { // TODO: We should probably not have it all be inline or not inline. // For example, in tuple types or constructors, we could have line breaks. maybe_grow(|| { self.skip_trivia_inline()?; let ini_idx = *self.index(); let lft = if self.try_parse_keyword("Any") { Type::Any } else if self.try_parse_keyword("None") { Type::None } else if self.try_parse_keyword("_") { Type::Hole } else if self.try_parse_keyword("u24") { Type::U24 } else if self.try_parse_keyword("i24") { Type::I24 } else if self.try_parse_keyword("f24") { Type::F24 } else if self.try_consume_exactly("(") { // Tuple or parenthesized expression self.skip_trivia(); let head = self.parse_type_expr()?; self.skip_trivia(); if self.try_consume_exactly(")") { // Parens head } else if self.starts_with(",") { // Tuple let mut types = vec![head]; loop { self.consume_exactly(",")?; types.push(self.parse_type_expr()?); if self.try_consume_exactly(")") { break; } if !self.starts_with(",") { return self.expected("',' or ')'"); } } Type::Tup(types) } else { let end_idx = *self.index(); return self.expected_spanned("tuple type or parenthesized type", ini_idx..end_idx); } } else { // Variable or Constructor // TODO: This will show "expected Name" instead of "expected type" let name = self.parse_var_name()?; self.skip_trivia_inline()?; if self.try_consume_exactly("(") { // Constructor with arguments // name "(" (type ("," type)* ","?)? ")" let args = self.list_like(|p| p.parse_type_expr(), "", ")", ",", true, 0)?; Type::Ctr(name, args) } else { // Variable Type::Var(name) } }; // Handle arrow types self.skip_trivia_inline()?; if self.try_consume_exactly("->") { let rgt = self.parse_type_expr()?; Ok(Type::Arr(Box::new(lft), Box::new(rgt))) } else { Ok(lft) } }) } fn parse_def_aux(&mut self, mut indent: Indent) -> ParseResult<(Definition, Indent)> { let ini_idx = *self.index(); self.parse_keyword("def")?; self.skip_trivia_inline()?; let check = if self.try_parse_keyword("unchecked") { (false, true) } else if self.try_parse_keyword("checked") { (true, false) } else { (false, false) }; self.skip_trivia_inline()?; let name = self.parse_top_level_name()?; self.skip_trivia_inline()?; let args = if self.try_consume_exactly("(") { self.list_like(|p| p.parse_def_arg(), "", ")", ",", true, 0)? } else { vec![] }; self.skip_trivia_inline()?; let (args, arg_types): (Vec<_>, Vec<_>) = args.into_iter().unzip(); let ret_type = self.parse_return_type()?; self.skip_trivia_inline()?; self.consume_exactly(":")?; self.consume_new_line()?; indent.enter_level(); self.consume_indent_exactly(indent)?; let (body, nxt_indent) = self.parse_statement(&mut indent)?; indent.exit_level(); // If any annotation, check by default, otherwise unchecked by default let check = if check.0 { true } else if check.1 { false } else { ret_type.is_some() || arg_types.iter().any(|t| t.is_some()) }; let arg_types = arg_types.into_iter().map(|t| t.unwrap_or(Type::Any)).collect::>(); let typ = make_fn_type(arg_types, ret_type.unwrap_or(Type::Any)); // Note: The source kind gets replaced later (generated if a local def, user otherwise) let source = Source::from_file_span(&self.file, self.input, ini_idx..self.index, self.builtin); let def = Definition { name, args, typ, check, body, source }; Ok((def, nxt_indent)) } fn parse_def_arg(&mut self) -> ParseResult<(Name, Option)> { let name = self.parse_var_name()?; self.skip_trivia_inline()?; if self.try_consume_exactly(":") { let typ = self.parse_type_expr()?; Ok((name, Some(typ))) } else { Ok((name, None)) } } fn parse_return_type(&mut self) -> ParseResult> { if self.try_consume_exactly("->") { Ok(Some(self.parse_type_expr()?)) } else { Ok(None) } } fn expected_indent(&mut self, expected: Indent, got: Indent) -> ParseResult { match (expected, got) { (Indent::Eof, Indent::Eof) => unreachable!(), (Indent::Eof, Indent::Val(got)) => { let msg = format!("Indentation error. Expected end-of-input, got {} spaces.", got); let idx = *self.index(); self.with_ctx(Err(msg), idx..idx + 1) } (Indent::Val(expected), Indent::Eof) => { let msg = format!("Indentation error. Expected {} spaces, got end-of-input.", expected); let idx = *self.index(); self.with_ctx(Err(msg), idx..idx + 1) } (Indent::Val(expected), Indent::Val(got)) => { if got != expected { let msg = format!("Indentation error. Expected {} spaces, got {}.", expected, got); let idx = *self.index(); self.with_ctx(Err(msg), idx..idx + 1) } else { unreachable!() } } } } } impl<'a> ParserCommons<'a> for ImpParser<'a> {} impl<'a> Parser<'a> for ImpParser<'a> { fn input(&mut self) -> &'a str { self.input } fn index(&mut self) -> &mut usize { &mut self.index } /// Generates an error message for parsing failures, including the highlighted context. /// /// Override to have our own error message. fn expected(&mut self, exp: &str) -> ParseResult { let ini_idx = *self.index(); let end_idx = *self.index() + 1; self.expected_spanned(exp, ini_idx..end_idx) } /// Consumes an instance of the given string, erroring if it is not found. /// /// Override to have our own error message. fn consume(&mut self, text: &str) -> ParseResult<()> { self.skip_trivia(); if self.input().get(*self.index()..).unwrap_or_default().starts_with(text) { *self.index() += text.len(); Ok(()) } else { self.expected(format!("'{text}'").as_str()) } } fn skip_trivia(&mut self) { while let Some(c) = self.peek_one() { if c.is_ascii_whitespace() { self.advance_one(); continue; } if c == '#' { while let Some(c) = self.peek_one() { if c != '\n' { self.advance_one(); } else { break; } } self.advance_one(); // Skip the newline character as well continue; } break; } } } impl Op { fn precedence(&self) -> usize { match self { Op::OR => 0, Op::XOR => 1, Op::AND => 2, Op::EQ => 3, Op::NEQ => 3, Op::LT => 4, Op::GT => 4, Op::LE => 4, Op::GE => 4, Op::SHL => 5, Op::SHR => 5, Op::ADD => 6, Op::SUB => 6, Op::MUL => 7, Op::DIV => 7, Op::REM => 7, Op::POW => 8, } } fn max_precedence() -> usize { 8 } } ================================================ FILE: src/imp/to_fun.rs ================================================ use super::{AssignPattern, Definition, Expr, InPlaceOp, Stmt}; use crate::{ diagnostics::Diagnostics, fun::{ self, builtins::{LCONS, LNIL}, parser::ParseBook, Book, Name, }, }; impl ParseBook { // TODO: Change all functions to return diagnostics pub fn to_fun(mut self) -> Result { for (name, mut def) in std::mem::take(&mut self.imp_defs) { def.order_kwargs(&self)?; def.gen_map_get(); if self.fun_defs.contains_key(&name) { panic!("Def names collision should be checked at parse time") } self.fun_defs.insert(name, def.to_fun()?); } let ParseBook { fun_defs: defs, hvm_defs, adts, ctrs, import_ctx, .. } = self; Ok(Book { defs, hvm_defs, adts, ctrs, entrypoint: None, imports: import_ctx.to_imports() }) } } impl Definition { pub fn to_fun(self) -> Result { let body = self.body.into_fun().map_err(|e| { let mut diags = Diagnostics::default(); diags.add_function_error(e, self.name.clone(), self.source.clone()); diags })?; let body = match body { StmtToFun::Return(term) => term, StmtToFun::Assign(..) => { let mut diags = Diagnostics::default(); diags.add_function_error( "Function doesn't end with a return statement", self.name, self.source.clone(), ); return Err(diags); } }; let rule = fun::Rule { pats: self.args.into_iter().map(|param| fun::Pattern::Var(Some(param))).collect(), body }; let def = fun::Definition { name: self.name, typ: self.typ, check: self.check, rules: vec![rule], source: self.source, }; Ok(def) } } impl AssignPattern { pub fn into_fun(self) -> fun::Pattern { match self { AssignPattern::Eraser => fun::Pattern::Var(None), AssignPattern::Var(name) => fun::Pattern::Var(Some(name)), AssignPattern::Chn(name) => fun::Pattern::Chn(name), AssignPattern::Tup(names) => fun::Pattern::Fan( fun::FanKind::Tup, fun::Tag::Static, names.into_iter().map(Self::into_fun).collect(), ), AssignPattern::Sup(names) => { fun::Pattern::Fan(fun::FanKind::Dup, fun::Tag::Auto, names.into_iter().map(Self::into_fun).collect()) } AssignPattern::MapSet(..) => unreachable!(), } } } #[derive(Debug)] enum StmtToFun { Return(fun::Term), Assign(bool, fun::Pattern, fun::Term), } fn take(t: Stmt) -> Result<(bool, Option, fun::Term), String> { match t.into_fun()? { StmtToFun::Return(ret) => Ok((false, None, ret)), StmtToFun::Assign(x, pat, val) => Ok((x, Some(pat), val)), } } fn wrap(nxt: Option, term: fun::Term, ask: bool) -> StmtToFun { if let Some(pat) = nxt { StmtToFun::Assign(ask, pat, term) } else { StmtToFun::Return(term) } } impl Stmt { fn into_fun(self) -> Result { // TODO: Refactor this to not repeat everything. // TODO: When we have an error with an assignment, we should show the offending assignment (eg. "{pat} = ..."). let stmt_to_fun = match self { Stmt::Assign { pat: AssignPattern::MapSet(map, key), val, nxt: Some(nxt) } => { let (ask, nxt_pat, nxt) = take(*nxt)?; let term = fun::Term::Let { pat: Box::new(fun::Pattern::Var(Some(map.clone()))), val: Box::new(fun::Term::call( fun::Term::Ref { nam: fun::Name::new("Map/set") }, [fun::Term::Var { nam: map }, key.to_fun(), val.to_fun()], )), nxt: Box::new(nxt), }; wrap(nxt_pat, term, ask) } Stmt::Assign { pat: AssignPattern::MapSet(..), val: _, nxt: None } => { return Err("Branch ends with map assignment.".to_string())?; } Stmt::Assign { pat, val, nxt: Some(nxt) } => { let pat = pat.into_fun(); let val = val.to_fun(); let (ask, nxt_pat, nxt) = take(*nxt)?; let term = fun::Term::Let { pat: Box::new(pat), val: Box::new(val), nxt: Box::new(nxt) }; wrap(nxt_pat, term, ask) } Stmt::Assign { pat, val, nxt: None } => { let pat = pat.into_fun(); let val = val.to_fun(); StmtToFun::Assign(false, pat, val) } Stmt::InPlace { op, pat, val, nxt } => { let (ask, nxt_pat, nxt) = take(*nxt)?; // if it is a mapper operation if let InPlaceOp::Map = op { let term = match &*pat { AssignPattern::MapSet(map, key) => { let rhs = fun::Term::call( fun::Term::r#ref("Map/map"), [fun::Term::Var { nam: map.clone() }, key.clone().to_fun(), val.clone().to_fun()], ); fun::Term::Let { pat: Box::new(fun::Pattern::Var(Some(map.clone()))), val: Box::new(rhs), nxt: Box::new(nxt), } } _ => { let rhs = fun::Term::call(val.to_fun(), [pat.clone().into_fun().to_term()]); fun::Term::Let { pat: Box::new(pat.into_fun()), val: Box::new(rhs), nxt: Box::new(nxt) } } }; return Ok(wrap(nxt_pat, term, ask)); } // otherwise match *pat { AssignPattern::Var(var) => { let term = fun::Term::Let { pat: Box::new(fun::Pattern::Var(Some(var.clone()))), val: Box::new(fun::Term::Oper { opr: op.to_lang_op(), fst: Box::new(fun::Term::Var { nam: var }), snd: Box::new(val.to_fun()), }), nxt: Box::new(nxt), }; wrap(nxt_pat, term, ask) } AssignPattern::MapSet(map, key) => { let temp = Name::new("%0"); let partial = Expr::Opr { op: op.to_lang_op(), lhs: Box::new(Expr::Var { nam: temp.clone() }), rhs: val }; let map_fn = Expr::Lam { names: vec![(temp, false)], bod: Box::new(partial) }; let map_term = fun::Term::call( fun::Term::r#ref("Map/map"), [fun::Term::Var { nam: map.clone() }, key.to_fun(), map_fn.to_fun()], ); let term = fun::Term::Let { pat: Box::new(fun::Pattern::Var(Some(map))), val: Box::new(map_term), nxt: Box::new(nxt), }; wrap(nxt_pat, term, ask) } _ => unreachable!(), } } Stmt::If { cond, then, otherwise, nxt } => { let (ask, pat, then, else_) = match (then.into_fun()?, otherwise.into_fun()?) { (StmtToFun::Return(t), StmtToFun::Return(e)) => (false, None, t, e), (StmtToFun::Assign(ask, tp, t), StmtToFun::Assign(ask_, ep, e)) if tp == ep => { (ask && ask_, Some(tp), t, e) } (StmtToFun::Assign(..), StmtToFun::Assign(..)) => { return Err("'if' branches end with different assignments.".to_string())?; } (StmtToFun::Return(..), StmtToFun::Assign(..)) => { return Err( "Expected 'else' branch from 'if' to return, but it ends with assignment.".to_string(), )?; } (StmtToFun::Assign(..), StmtToFun::Return(..)) => { return Err( "Expected 'else' branch from 'if' to end with assignment, but it returns.".to_string(), )?; } }; let arms = vec![else_, then]; let term = fun::Term::Swt { arg: Box::new(cond.to_fun()), bnd: Some(Name::new("%pred")), with_bnd: vec![], with_arg: vec![], pred: Some(Name::new("%pred-1")), arms, }; wrap_nxt_assign_stmt(term, nxt, pat, ask)? } Stmt::Match { arg, bnd, with_bnd, with_arg, arms, nxt } => { let arg = arg.to_fun(); let mut fun_arms = vec![]; let mut arms = arms.into_iter(); let fst = arms.next().unwrap(); let (fst_ask, fst_pat, fst_rgt) = take(fst.rgt)?; let with_arg = with_arg.into_iter().map(Expr::to_fun).collect(); fun_arms.push((fst.lft, vec![], fst_rgt)); for arm in arms { let (arm_ask, arm_pat, arm_rgt) = take(arm.rgt)?; match (&arm_pat, &fst_pat) { (Some(arm_pat), Some(fst_pat)) if arm_pat != fst_pat || arm_ask != fst_ask => { return Err("'match' arms end with different assignments.".to_string())?; } (Some(_), None) => { return Err("Expected 'match' arms to end with assignment, but it returns.".to_string())?; } (None, Some(_)) => { return Err("Expected 'match' arms to return, but it ends with assignment.".to_string())?; } (Some(_), Some(_)) => fun_arms.push((arm.lft, vec![], arm_rgt)), (None, None) => fun_arms.push((arm.lft, vec![], arm_rgt)), } } let term = fun::Term::Mat { arg: Box::new(arg), bnd, with_bnd, with_arg, arms: fun_arms }; wrap_nxt_assign_stmt(term, nxt, fst_pat, fst_ask)? } Stmt::Switch { arg, bnd, with_bnd, with_arg, arms, nxt } => { let arg = arg.to_fun(); let mut fun_arms = vec![]; let mut arms = arms.into_iter(); let fst = arms.next().unwrap(); let (fst_ask, fst_pat, fst) = take(fst)?; let with_arg = with_arg.into_iter().map(Expr::to_fun).collect(); fun_arms.push(fst); for arm in arms { let (arm_ask, arm_pat, arm) = take(arm)?; match (&arm_pat, &fst_pat) { (Some(arm_pat), Some(fst_pat)) if arm_pat != fst_pat || arm_ask != fst_ask => { return Err("'switch' arms end with different assignments.".to_string())?; } (Some(_), None) => { return Err("Expected 'switch' arms to end with assignment, but it returns.".to_string())?; } (None, Some(_)) => { return Err("Expected 'switch' arms to return, but it ends with assignment.".to_string())?; } (Some(_), Some(_)) => fun_arms.push(arm), (None, None) => fun_arms.push(arm), } } let pred = Some(Name::new(format!("{}-{}", bnd.clone().unwrap(), fun_arms.len() - 1))); let term = fun::Term::Swt { arg: Box::new(arg), bnd, with_bnd, with_arg, pred, arms: fun_arms }; wrap_nxt_assign_stmt(term, nxt, fst_pat, fst_ask)? } Stmt::Fold { arg, bnd, with_bnd, with_arg, arms, nxt } => { let arg = arg.to_fun(); let mut fun_arms = vec![]; let mut arms = arms.into_iter(); let fst = arms.next().unwrap(); let (fst_ask, fst_pat, fst_rgt) = take(fst.rgt)?; fun_arms.push((fst.lft, vec![], fst_rgt)); let with_arg = with_arg.into_iter().map(Expr::to_fun).collect(); for arm in arms { let (arm_ask, arm_pat, arm_rgt) = take(arm.rgt)?; match (&arm_pat, &fst_pat) { (Some(arm_pat), Some(fst_pat)) if arm_pat != fst_pat || arm_ask != fst_ask => { return Err("'fold' arms end with different assignments.".to_string())?; } (Some(_), None) => { return Err("Expected 'fold' arms to end with assignment, but it returns.".to_string())?; } (None, Some(_)) => { return Err("Expected 'fold' arms to return, but it ends with assignment.".to_string())?; } (Some(_), Some(_)) => fun_arms.push((arm.lft, vec![], arm_rgt)), (None, None) => fun_arms.push((arm.lft, vec![], arm_rgt)), } } let term = fun::Term::Fold { arg: Box::new(arg), bnd, with_bnd, with_arg, arms: fun_arms }; wrap_nxt_assign_stmt(term, nxt, fst_pat, fst_ask)? } Stmt::Bend { bnd, arg, cond, step, base, nxt } => { let arg = arg.into_iter().map(Expr::to_fun).collect(); let cond = cond.to_fun(); let (ask, pat, step, base) = match (step.into_fun()?, base.into_fun()?) { (StmtToFun::Return(s), StmtToFun::Return(b)) => (false, None, s, b), (StmtToFun::Assign(aa, sp, s), StmtToFun::Assign(ba, bp, b)) if sp == bp => { (aa && ba, Some(sp), s, b) } (StmtToFun::Assign(..), StmtToFun::Assign(..)) => { return Err("'bend' branches end with different assignments.".to_string())?; } (StmtToFun::Return(..), StmtToFun::Assign(..)) => { return Err( "Expected 'else' branch from 'bend' to return, but it ends with assignment.".to_string(), )?; } (StmtToFun::Assign(..), StmtToFun::Return(..)) => { return Err( "Expected 'else' branch from 'bend' to end with assignment, but it returns.".to_string(), )?; } }; let term = fun::Term::Bend { bnd, arg, cond: Box::new(cond), step: Box::new(step), base: Box::new(base) }; wrap_nxt_assign_stmt(term, nxt, pat, ask)? } Stmt::With { typ, bod, nxt } => { let (ask, pat, bod) = take(*bod)?; let term = fun::Term::With { typ, bod: Box::new(bod) }; wrap_nxt_assign_stmt(term, nxt, pat, ask)? } Stmt::Ask { pat, val, nxt: Some(nxt) } => { let (ask, nxt_pat, nxt) = take(*nxt)?; let term = fun::Term::Ask { pat: Box::new(pat.into_fun()), val: Box::new(val.to_fun()), nxt: Box::new(nxt) }; wrap(nxt_pat, term, ask) } Stmt::Ask { pat, val, nxt: None } => { let pat = pat.into_fun(); let val = val.to_fun(); StmtToFun::Assign(true, pat, val) } Stmt::Open { typ, var, nxt } => { let (ask, nxt_pat, nxt) = take(*nxt)?; let term = fun::Term::Open { typ, var, bod: Box::new(nxt) }; wrap(nxt_pat, term, ask) } Stmt::Use { nam, val, nxt } => { let (ask, nxt_pat, nxt) = take(*nxt)?; let term = fun::Term::Use { nam: Some(nam), val: Box::new(val.to_fun()), nxt: Box::new(nxt) }; wrap(nxt_pat, term, ask) } Stmt::Return { term } => StmtToFun::Return(term.to_fun()), Stmt::LocalDef { def, nxt } => { let (ask, nxt_pat, nxt) = take(*nxt)?; let def = def.to_fun().map_err(|e| e.display_only_messages().to_string())?; let term = fun::Term::Def { def, nxt: Box::new(nxt) }; wrap(nxt_pat, term, ask) } Stmt::Err => unreachable!(), }; Ok(stmt_to_fun) } } impl Expr { pub fn to_fun(self) -> fun::Term { match self { Expr::Era => fun::Term::Era, Expr::Var { nam } => fun::Term::Var { nam }, Expr::Chn { nam } => fun::Term::Link { nam }, Expr::Num { val } => fun::Term::Num { val }, Expr::Call { fun, args, kwargs } => { assert!(kwargs.is_empty()); let args = args.into_iter().map(Self::to_fun); fun::Term::call(fun.to_fun(), args) } Expr::Lam { names, bod } => names.into_iter().rfold(bod.to_fun(), |acc, (name, link)| fun::Term::Lam { tag: fun::Tag::Static, pat: Box::new(if link { fun::Pattern::Chn(name) } else { fun::Pattern::Var(Some(name)) }), bod: Box::new(acc), }), Expr::Opr { op, lhs, rhs } => { fun::Term::Oper { opr: op, fst: Box::new(lhs.to_fun()), snd: Box::new(rhs.to_fun()) } } Expr::Str { val } => fun::Term::Str { val }, Expr::Lst { els } => fun::Term::List { els: els.into_iter().map(Self::to_fun).collect() }, Expr::Tup { els } => fun::Term::Fan { fan: fun::FanKind::Tup, tag: fun::Tag::Static, els: els.into_iter().map(Self::to_fun).collect(), }, Expr::Sup { els } => fun::Term::Fan { fan: fun::FanKind::Dup, tag: fun::Tag::Auto, els: els.into_iter().map(Self::to_fun).collect(), }, Expr::Ctr { name, args, kwargs } => { assert!(kwargs.is_empty()); let args = args.into_iter().map(Self::to_fun); fun::Term::call(fun::Term::Var { nam: name }, args) } Expr::LstMap { term, bind, iter, cond } => { const ITER_TAIL: &str = "%iter.tail"; const ITER_HEAD: &str = "%iter.head"; let cons_branch = fun::Term::call( fun::Term::r#ref(LCONS), [term.to_fun(), fun::Term::Var { nam: Name::new(ITER_TAIL) }], ); let cons_branch = if let Some(cond) = cond { fun::Term::Swt { arg: Box::new(cond.to_fun()), bnd: Some(Name::new("%comprehension")), with_bnd: vec![], with_arg: vec![], pred: Some(Name::new("%comprehension-1")), arms: vec![fun::Term::Var { nam: Name::new(ITER_TAIL) }, cons_branch], } } else { cons_branch }; let cons_branch = fun::Term::Let { pat: Box::new(fun::Pattern::Var(Some(bind))), val: Box::new(fun::Term::Var { nam: Name::new(ITER_HEAD) }), nxt: Box::new(cons_branch), }; fun::Term::Fold { bnd: Some(Name::new("%iter")), arg: Box::new(iter.to_fun()), with_bnd: vec![], with_arg: vec![], arms: vec![ (Some(Name::new(LNIL)), vec![], fun::Term::r#ref(LNIL)), (Some(Name::new(LCONS)), vec![], cons_branch), ], } } Expr::Map { entries } => map_init(entries), Expr::MapGet { .. } => unreachable!(), Expr::TreeNode { left, right } => { let left = left.to_fun(); let right = right.to_fun(); fun::Term::call(fun::Term::r#ref("Tree/Node"), [left, right]) } Expr::TreeLeaf { val } => { let val = val.to_fun(); fun::Term::app(fun::Term::r#ref("Tree/Leaf"), val) } } } } fn map_init(entries: Vec<(Expr, Expr)>) -> fun::Term { let mut map = fun::Term::Ref { nam: fun::Name::new("Map/empty") }; for (key, value) in entries { map = fun::Term::call(fun::Term::Ref { nam: fun::Name::new("Map/set") }, [map, key.to_fun(), value.to_fun()]); } map } /// If the statement was a return, returns it, erroring if there is another after it. /// Otherwise, turns it into a 'let' and returns the next statement. fn wrap_nxt_assign_stmt( term: fun::Term, nxt: Option>, pat: Option, ask: bool, ) -> Result { if let Some(nxt) = nxt { if let Some(pat) = pat { let (ask_nxt, nxt_pat, nxt) = take(*nxt)?; let term = if ask { fun::Term::Ask { pat: Box::new(pat), val: Box::new(term), nxt: Box::new(nxt) } } else { fun::Term::Let { pat: Box::new(pat), val: Box::new(term), nxt: Box::new(nxt) } }; Ok(wrap(nxt_pat, term, ask_nxt)) } else { Err("Statement ends with return but is not at end of function.".to_string())? } } else if let Some(pat) = pat { Ok(StmtToFun::Assign(ask, pat, term)) } else { Ok(StmtToFun::Return(term)) } } ================================================ FILE: src/imports/book.rs ================================================ use super::{BindMap, ImportsMap, PackageLoader}; use crate::{ diagnostics::{Diagnostics, DiagnosticsConfig}, fun::{ parser::ParseBook, Adt, AdtCtr, Book, Definition, HvmDefinition, Name, Pattern, Source, SourceKind, Term, }, imp::{self, Expr, MatchArm, Stmt}, imports::packages::Packages, maybe_grow, }; use indexmap::{map::Entry, IndexMap}; use itertools::Itertools; impl ParseBook { /// Loads and applies imports recursively to a ParseBook, /// transforming definitions and ADTs to a canonical name, /// and adding `use` binds so that names are accessible by their alias. /// /// # Details /// /// The process involves: /// /// 1. Loading imports recursively using the provided `loader`. /// 2. Transforming definitions and ADTs with naming transformations. /// 3. Adding binds for aliases and old names in their respective definitions. /// 4. Converting the ParseBook into its functional form. /// 5. Perform any necessary post-processing. pub fn load_imports( self, mut loader: impl PackageLoader, diag_config: DiagnosticsConfig, ) -> Result { let diag = &mut Diagnostics::new(diag_config); let pkgs = &mut Packages::new(self); // Load all the imports recursively, saving them in `pkgs`. // `book` is the root book with the entry point. let mut book = pkgs.load_imports(&mut loader, diag)?; // Apply the imports to the book book.apply_imports(None, diag, pkgs)?; diag.fatal(())?; eprint!("{}", diag); // Convert the parse-level AST into the internal functional representation. let mut book = book.to_fun()?; // Process terms that contains constructors names and can't be updated by `desugar_use`. book.desugar_ctr_use(); Ok(book) } /// Loads the imported books recursively into the importing book, /// then apply imported names or aliases binds to its definitions. fn apply_imports( &mut self, main_imports: Option<&ImportsMap>, diag: &mut Diagnostics, pkgs: &mut Packages, ) -> Result<(), Diagnostics> { self.load_packages(main_imports, diag, pkgs)?; self.apply_import_binds(main_imports, pkgs); Ok(()) } /// Consumes the book imported packages, /// applying the imports recursively of every nested book. fn load_packages( &mut self, main_imports: Option<&ImportsMap>, diag: &mut Diagnostics, pkgs: &mut Packages, ) -> Result<(), Diagnostics> { let sources = self.import_ctx.sources().into_iter().cloned().collect_vec(); for src in sources { let Some(package) = pkgs.books.swap_remove(&src) else { continue }; let mut package = package.into_inner(); // Can not be done outside the loop/function because of the borrow checker. // Just serves to pass only the import map of the first call to `apply_imports_go`. let main_imports = main_imports.unwrap_or(&self.import_ctx.map); package.apply_imports(Some(main_imports), diag, pkgs)?; // Rename ADTs and defs, applying binds from old names to new names package.apply_adts(&src, main_imports); package.apply_defs(&src, main_imports); let Book { defs, hvm_defs, adts, .. } = package.to_fun()?; // Add the ADTs to the importing book, // saving the constructors names to be used when applying ADTs binds. for (name, adt) in adts { let adts = pkgs.loaded_adts.entry(src.clone()).or_default(); adts.insert(name.clone(), adt.ctrs.keys().cloned().collect_vec()); self.add_imported_adt(name, adt, diag); } // The names on the indexmap are the original ones, so we ignore them for def in defs.into_values() { self.add_imported_def(def, diag); } // The names on the indexmap are the original ones, so we ignore them for def in hvm_defs.into_values() { self.add_imported_hvm_def(def, diag); } } Ok(()) } /// Applies a chain of `use bind = src` to every local definition. /// /// Must be used after `load_packages` fn apply_import_binds(&mut self, main_imports: Option<&ImportsMap>, pkgs: &Packages) { // Can not be done outside the function because of the borrow checker. // Just serves to pass only the import map of the first call to `apply_imports_go`. let main_imports = main_imports.unwrap_or(&self.import_ctx.map); let mut local_imports = BindMap::new(); let mut adt_imports = BindMap::new(); // Collect local imports binds, starting with `__` if not imported by the main book. 'outer: for (bind, src) in self.import_ctx.map.binds.iter().rev() { if self.contains_def(bind) | self.ctrs.contains_key(bind) | self.adts.contains_key(bind) { // TODO: Here we should show warnings for shadowing of imported names by local def/ctr/adt // It can be done, but when importing with `ImportType::Single` files in the same folder, // it gives a false positive warning continue; } let nam = if main_imports.contains_source(src) { src.clone() } else { Name::new(format!("__{}", src)) }; // Checks if the bind is an loaded ADT name, // If so, add the constructors binds as `bind/ctr` instead. for pkg in self.import_ctx.sources() { if let Some(book) = pkgs.loaded_adts.get(pkg) { if let Some(ctrs) = book.get(&nam) { for ctr in ctrs.iter().rev() { let full_ctr_name = ctr.split("__").nth(1).unwrap_or(ctr.as_ref()); let ctr_name = full_ctr_name.strip_prefix(src.as_ref()).unwrap(); let bind = Name::new(format!("{}{}", bind, ctr_name)); local_imports.insert(bind, ctr.clone()); } // Add a mapping of the ADT name adt_imports.insert(bind.clone(), nam.clone()); continue 'outer; } } } // Not a constructor, so just insert the bind. local_imports.insert(bind.clone(), nam); } for (_, def) in self.local_defs_mut() { def.apply_binds(true, &local_imports); def.apply_type_binds(&adt_imports); } } /// Applying the necessary naming transformations to the book ADTs, /// adding `use ctr = ctr_src` chains to every local definition and /// substituting the name of type ctrs for the canonical ones. fn apply_adts(&mut self, src: &Name, main_imports: &ImportsMap) { let adts = std::mem::take(&mut self.adts); let mut new_adts = IndexMap::new(); let mut adts_map = vec![]; let mut ctrs_map = IndexMap::new(); let mut new_ctrs = IndexMap::new(); // Rename the ADTs and constructors to their canonical name, // starting with `__` if not imported by the main book. for (mut name, mut adt) in adts { if adt.source.is_local() { adt.source.kind = SourceKind::Imported; let old_name = name.clone(); name = Name::new(format!("{}/{}", src, name)); let mangle_name = !main_imports.contains_source(&name); let mut mangle_adt_name = mangle_name; for (old_nam, ctr) in std::mem::take(&mut adt.ctrs) { let mut ctr_name = Name::new(format!("{}/{}", src, old_nam)); let mangle_ctr = mangle_name && !main_imports.contains_source(&ctr_name); if mangle_ctr { mangle_adt_name = true; ctr_name = Name::new(format!("__{}", ctr_name)); } let ctr = AdtCtr { name: ctr_name.clone(), ..ctr }; new_ctrs.insert(ctr_name.clone(), name.clone()); ctrs_map.insert(old_nam, ctr_name.clone()); adt.ctrs.insert(ctr_name, ctr); } if mangle_adt_name { name = Name::new(format!("__{}", name)); } adt.name = name.clone(); adts_map.push((old_name, name.clone())); } new_adts.insert(name.clone(), adt); } // Apply the binds for the type constructors in the constructor types for (_, adt) in &mut new_adts { for (_, ctr) in &mut adt.ctrs { for (from, to) in &adts_map { ctr.typ.subst_ctr(from, to); } } } let adts_map = adts_map.into_iter().collect::>(); for (_, def) in self.local_defs_mut() { // Applies the binds for the new constructor names for every definition. def.apply_binds(true, &ctrs_map); // Apply the binds for the type constructors in the def types and in the `def` terms. def.apply_type_binds(&adts_map); } self.adts = new_adts; self.ctrs = new_ctrs; } /// Apply the necessary naming transformations to the book definitions, /// adding `use def = def_src` chains to every local definition. fn apply_defs(&mut self, src: &Name, main_imports: &ImportsMap) { let mut canonical_map: IndexMap<_, _> = IndexMap::new(); // Rename the definitions to their canonical name // Starting with `__` if not imported by the main book. for (_, def) in self.local_defs_mut() { def.canonicalize_name(src, main_imports, &mut canonical_map); } // Applies the binds for the new names for every definition for (_, def) in self.local_defs_mut() { def.apply_binds(false, &canonical_map); def.source_mut().kind = SourceKind::Imported; } } } /// Helper functions impl ParseBook { pub fn top_level_names(&self) -> impl Iterator { let imp_defs = self.imp_defs.keys(); let fun_defs = self.fun_defs.keys(); let hvm_defs = self.hvm_defs.keys(); let adts = self.adts.keys(); let ctrs = self.ctrs.keys(); imp_defs.chain(fun_defs).chain(hvm_defs).chain(adts).chain(ctrs) } fn add_imported_adt(&mut self, nam: Name, adt: Adt, diag: &mut Diagnostics) { if self.adts.get(&nam).is_some() { let err = format!("The imported datatype '{nam}' conflicts with the datatype '{nam}'."); diag.add_book_error(err); } else { for ctr in adt.ctrs.keys() { if self.contains_def(ctr) { let err = format!("The imported constructor '{ctr}' conflicts with the definition '{ctr}'."); diag.add_book_error(err); } match self.ctrs.entry(ctr.clone()) { Entry::Vacant(e) => _ = e.insert(nam.clone()), Entry::Occupied(e) => { let ctr = e.key(); let err = format!("The imported constructor '{ctr}' conflicts with the constructor '{ctr}'."); diag.add_book_error(err); } } } self.adts.insert(nam, adt); } } fn add_imported_def(&mut self, def: Definition, diag: &mut Diagnostics) { if !self.has_def_conflict(&def.name, diag) { self.fun_defs.insert(def.name.clone(), def); } } fn add_imported_hvm_def(&mut self, def: HvmDefinition, diag: &mut Diagnostics) { if !self.has_def_conflict(&def.name, diag) { self.hvm_defs.insert(def.name.clone(), def); } } fn has_def_conflict(&mut self, name: &Name, diag: &mut Diagnostics) -> bool { if self.contains_def(name) { let err = format!("The imported definition '{name}' conflicts with the definition '{name}'."); diag.add_book_error(err); true } else if self.ctrs.contains_key(name) { let err = format!("The imported definition '{name}' conflicts with the constructor '{name}'."); diag.add_book_error(err); true } else { false } } fn local_defs_mut(&mut self) -> impl Iterator { let fun = self.fun_defs.iter_mut().map(|(nam, def)| (nam, def as &mut dyn Def)); let imp = self.imp_defs.iter_mut().map(|(nam, def)| (nam, def as &mut dyn Def)); let hvm = self.hvm_defs.iter_mut().map(|(nam, def)| (nam, def as &mut dyn Def)); fun.chain(imp).chain(hvm).filter(|(_, def)| def.source().is_local()) } } /// Common functions for the different definition types trait Def { fn canonicalize_name(&mut self, src: &Name, main_imports: &ImportsMap, binds: &mut BindMap) { let def_name = self.name_mut(); let mut new_name = Name::new(format!("{}/{}", src, def_name)); if !main_imports.contains_source(&new_name) { new_name = Name::new(format!("__{}", new_name)); } binds.insert(def_name.clone(), new_name.clone()); *def_name = new_name; } /// Applies the binds for definition names by placing `use` terms. /// /// If we know that the bind map doesn't contain any constructor names, /// we skip renaming rule patterns. fn apply_binds(&mut self, maybe_constructor: bool, binds: &BindMap); fn apply_type_binds(&mut self, binds: &BindMap); fn source(&self) -> &Source; fn source_mut(&mut self) -> &mut Source; fn name_mut(&mut self) -> &mut Name; } impl Def for Definition { fn apply_binds(&mut self, maybe_constructor: bool, binds: &BindMap) { fn rename_ctr_pattern(pat: &mut Pattern, binds: &BindMap) { for pat in pat.children_mut() { rename_ctr_pattern(pat, binds); } match pat { Pattern::Ctr(nam, _) => { if let Some(alias) = binds.get(nam) { *nam = alias.clone(); } } Pattern::Var(Some(nam)) => { if let Some(alias) = binds.get(nam) { *nam = alias.clone(); } } _ => {} } } for rule in &mut self.rules { if maybe_constructor { for pat in &mut rule.pats { rename_ctr_pattern(pat, binds); } } let bod = std::mem::take(&mut rule.body); rule.body = bod.fold_uses(binds.iter().rev()); } } fn apply_type_binds(&mut self, binds: &BindMap) { for (from, to) in binds.iter().rev() { self.typ.subst_ctr(from, to); for rule in &mut self.rules { rule.body.subst_type_ctrs(from, to); } } } fn source(&self) -> &Source { &self.source } fn source_mut(&mut self) -> &mut Source { &mut self.source } fn name_mut(&mut self) -> &mut Name { &mut self.name } } impl Def for imp::Definition { fn apply_binds(&mut self, _maybe_constructor: bool, binds: &BindMap) { let bod = std::mem::take(&mut self.body); self.body = bod.fold_uses(binds.iter().rev()); } fn apply_type_binds(&mut self, binds: &BindMap) { fn subst_type_ctrs_stmt(stmt: &mut Stmt, from: &Name, to: &Name) { maybe_grow(|| match stmt { Stmt::Assign { nxt, .. } => { if let Some(nxt) = nxt { subst_type_ctrs_stmt(nxt, from, to); } } Stmt::InPlace { nxt, .. } => { subst_type_ctrs_stmt(nxt, from, to); } Stmt::If { then, otherwise, nxt, .. } => { subst_type_ctrs_stmt(then, from, to); subst_type_ctrs_stmt(otherwise, from, to); if let Some(nxt) = nxt { subst_type_ctrs_stmt(nxt, from, to); } } Stmt::Match { arms, nxt, .. } => { for MatchArm { lft: _, rgt } in arms { subst_type_ctrs_stmt(rgt, from, to); } if let Some(nxt) = nxt { subst_type_ctrs_stmt(nxt, from, to); } } Stmt::Switch { arms, nxt, .. } => { for arm in arms { subst_type_ctrs_stmt(arm, from, to); } if let Some(nxt) = nxt { subst_type_ctrs_stmt(nxt, from, to); } } Stmt::Bend { step, base, nxt, .. } => { subst_type_ctrs_stmt(step, from, to); subst_type_ctrs_stmt(base, from, to); if let Some(nxt) = nxt { subst_type_ctrs_stmt(nxt, from, to); } } Stmt::Fold { arms, nxt, .. } => { for MatchArm { lft: _, rgt } in arms { subst_type_ctrs_stmt(rgt, from, to); } if let Some(nxt) = nxt { subst_type_ctrs_stmt(nxt, from, to); } } Stmt::With { typ, bod, nxt } => { if typ == from { *typ = to.clone(); } subst_type_ctrs_stmt(bod, from, to); if let Some(nxt) = nxt { subst_type_ctrs_stmt(nxt, from, to); } } Stmt::Ask { nxt, .. } => { if let Some(nxt) = nxt { subst_type_ctrs_stmt(nxt, from, to); } } Stmt::Return { .. } => {} Stmt::Open { typ, nxt, .. } => { if typ == from { *typ = to.clone(); } subst_type_ctrs_stmt(nxt, from, to); } Stmt::Use { nxt, .. } => { subst_type_ctrs_stmt(nxt, from, to); } Stmt::LocalDef { def, nxt } => { def.apply_type_binds(&[(from.clone(), to.clone())].into_iter().collect()); subst_type_ctrs_stmt(nxt, from, to); } Stmt::Err => {} }) } for (from, to) in binds.iter().rev() { self.typ.subst_ctr(from, to); subst_type_ctrs_stmt(&mut self.body, from, to); } } fn source(&self) -> &Source { &self.source } fn source_mut(&mut self) -> &mut Source { &mut self.source } fn name_mut(&mut self) -> &mut Name { &mut self.name } } impl Def for HvmDefinition { /// Do nothing, can not apply binds to a HvmDefinition. fn apply_binds(&mut self, _maybe_constructor: bool, _binds: &BindMap) {} fn apply_type_binds(&mut self, binds: &BindMap) { for (from, to) in binds.iter().rev() { self.typ.subst_ctr(from, to); } } fn source(&self) -> &Source { &self.source } fn source_mut(&mut self) -> &mut Source { &mut self.source } fn name_mut(&mut self) -> &mut Name { &mut self.name } fn canonicalize_name(&mut self, src: &Name, main_imports: &ImportsMap, binds: &mut BindMap) { let def_name = self.name_mut(); let mut new_name = Name::new(std::format!("{}/{}", src, def_name)); if !main_imports.contains_source(&new_name) { new_name = Name::new(std::format!("__{}", new_name)); } binds.insert(def_name.clone(), new_name.clone()); *def_name = new_name; } } impl Term { fn fold_uses<'a>(self, map: impl Iterator) -> Self { map.fold(self, |acc, (bind, nam)| Self::Use { nam: Some(bind.clone()), val: Box::new(Self::Var { nam: nam.clone() }), nxt: Box::new(acc), }) } } impl Stmt { fn fold_uses<'a>(self, map: impl Iterator) -> Self { map.fold(self, |acc, (bind, nam)| Self::Use { nam: bind.clone(), val: Box::new(Expr::Var { nam: nam.clone() }), nxt: Box::new(acc), }) } } ================================================ FILE: src/imports/loader.rs ================================================ use super::{BoundSource, Import, ImportType}; use crate::fun::Name; use indexmap::IndexMap; use std::{ collections::HashSet, path::{Component, Path, PathBuf}, }; pub type Sources = IndexMap; /// Trait to load packages from various sources. pub trait PackageLoader { /// Load a package specified by the `import` parameter. /// /// # Parameters /// /// - `import`: A mutable reference to an `Import` structure, which contains: /// - `path`: The path to the package or directory to be imported. /// - `imp_type`: The type of import, which can specify a single name, a list of names, or all names in a path. /// - `relative`: A boolean indicating if the path is relative to the current directory. /// - `src`: A `BoundSource` to be updated with the names of the located files. /// /// # Behavior /// /// The `load` method is responsible for locating and loading the requested package(s). /// The loaded packages are returned as a `Sources` map, where the key is the package name and the value is its content. /// Implementers must: /// /// - Track already loaded sources to avoid loading and returning them again. /// - Update `import.src` with the names of the found packages, even if they are not included in the `Sources` map. /// /// The implementation should handle the following import types: /// - **Single**: Load a specific file by its name. /// - **List**: Load a list of specified files or names from a specific file. /// - **Glob**: Load all files in a directory or all names from a specific file. fn load(&mut self, import: &mut Import) -> Result; } /// Default implementation of `PackageLoader` that loads packages from the local directory. pub struct DefaultLoader { local_path: PathBuf, loaded: HashSet, entrypoint: Name, } impl DefaultLoader { pub fn new(local_path: &Path) -> Self { let entrypoint = Name::new(local_path.file_stem().unwrap().to_string_lossy()); let local_path = local_path.parent().unwrap().to_path_buf(); Self { local_path, loaded: HashSet::new(), entrypoint } } fn read_file(&mut self, path: &Path, file_path: &str, src: &mut Sources) -> Result, String> { let normalized = normalize_path(&PathBuf::from(file_path)); let file_path = Name::new(normalized.to_string_lossy()); if self.entrypoint == file_path { return Err("Can not import the entry point of the program.".to_string()); }; if !self.is_loaded(&file_path) { self.loaded.insert(file_path.clone()); let path = path.with_extension("bend"); let Some(code) = std::fs::read_to_string(path).ok() else { return Ok(None) }; src.insert(file_path.clone(), code); } Ok(Some(file_path)) } fn read_file_in_folder( &mut self, full_path: &Path, folder: &str, file_name: &str, src: &mut Sources, ) -> Result, String> { let full_path = full_path.join(file_name); if folder.is_empty() { self.read_file(&full_path, file_name, src) } else { let file_name = &format!("{}/{}", folder, file_name); self.read_file(&full_path, file_name, src) } } fn read_path( &mut self, base_path: &Path, path: &Name, imp_type: &ImportType, ) -> Result, String> { let full_path = base_path.join(path.as_ref()); let mut src = IndexMap::new(); let (mut file, mut dir) = (None, None); if full_path.with_extension("bend").is_file() { file = self.read_file(&full_path, path.as_ref(), &mut src)?; } if full_path.is_dir() || path.is_empty() { let mut names = IndexMap::new(); match imp_type { ImportType::Single(file, _) => { if let Some(name) = self.read_file_in_folder(&full_path, path, file, &mut src)? { names.insert(file.clone(), name); } } ImportType::List(list) => { for (file, _) in list { if let Some(name) = self.read_file_in_folder(&full_path, path, file, &mut src)? { names.insert(file.clone(), name); } } } ImportType::Glob => { for entry in full_path.read_dir().unwrap().flatten() { let file = PathBuf::from(&entry.file_name()); if let Some("bend") = file.extension().and_then(|f| f.to_str()) { let file = file.file_stem().unwrap().to_string_lossy(); if let Some(name) = self.read_file_in_folder(&full_path, path, &file, &mut src)? { names.insert(Name::new(file), name); } } } } } if !names.is_empty() { dir = Some(names); } } let src = match (file, dir) { (Some(f), None) => Some((BoundSource::File(f), src)), (None, Some(d)) => Some((BoundSource::Dir(d), src)), (Some(f), Some(d)) => Some((BoundSource::Either(f, d), src)), (None, None) => None, }; Ok(src) } fn is_loaded(&self, name: &Name) -> bool { self.loaded.contains(name) } } pub const BEND_PATH: &[&str] = &[""]; impl PackageLoader for DefaultLoader { fn load(&mut self, import: &mut Import) -> Result { let mut sources = Sources::new(); let Import { path, imp_type, relative, src } = import; let folders = if *relative { vec![self.local_path.clone()] } else { BEND_PATH.iter().map(|p| self.local_path.join(p)).collect() }; for base in folders { let Some((names, new_pkgs)) = self.read_path(&base, path, imp_type)? else { continue }; *src = names; sources.extend(new_pkgs); break; } if let BoundSource::None = src { return Err(format!("Failed to import '{}' from '{}'", imp_type, path).to_string()); } Ok(sources) } } // Taken from 'cargo/util/paths.rs' pub fn normalize_path(path: &Path) -> PathBuf { let mut components = path.components().peekable(); let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().cloned() { components.next(); PathBuf::from(c.as_os_str()) } else { PathBuf::new() }; for component in components { match component { Component::Prefix(..) => unreachable!(), Component::RootDir => { ret.push(component.as_os_str()); } Component::CurDir => {} Component::ParentDir => { ret.pop(); } Component::Normal(c) => { ret.push(c); } } } ret } ================================================ FILE: src/imports/mod.rs ================================================ use crate::{ diagnostics::{Diagnostics, WarningType}, fun::Name, }; use indexmap::{IndexMap, IndexSet}; use itertools::Itertools; use std::fmt::Display; pub mod book; pub mod loader; pub mod packages; pub use loader::*; pub type BindMap = IndexMap; #[derive(Debug, Clone, Default)] pub struct ImportCtx { /// Imports declared in the program source. imports: Vec, /// Map from bound names to source package. map: ImportsMap, } impl ImportCtx { pub fn add_import(&mut self, import: Import) { self.imports.push(import); } pub fn to_imports(self) -> Vec { self.imports } pub fn sources(&self) -> Vec<&Name> { let mut names = Vec::new(); for imps in &self.imports { match &imps.src { BoundSource::None => {} BoundSource::File(f) => names.push(f), BoundSource::Dir(v) => names.extend(v.values()), BoundSource::Either(_, _) => unreachable!("This should be resolved into `File` or `Dir` by now"), } } names } } #[derive(Debug, Clone)] pub struct Import { pub path: Name, pub imp_type: ImportType, pub relative: bool, pub src: BoundSource, } impl Import { pub fn new(path: Name, imp_type: ImportType, relative: bool) -> Self { Self { path, imp_type, relative, src: BoundSource::None } } } #[derive(Debug, Clone)] pub enum ImportType { Single(Name, Option), List(Vec<(Name, Option)>), Glob, } impl Display for ImportType { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { ImportType::Single(n, _) => write!(f, "{n}"), ImportType::List(l) => write!(f, "({})", l.iter().map(|(n, _)| n).join(", ")), ImportType::Glob => write!(f, "*"), } } } #[derive(Debug, Clone)] pub enum BoundSource { None, File(Name), Dir(IndexMap), /// If the bound source is ambiguous between a file or a directory Either(Name, IndexMap), } #[derive(Debug, Clone, Default)] struct ImportsMap { binds: BindMap, } impl ImportsMap { pub fn contains_source(&self, s: &Name) -> bool { self.binds.values().contains(s) } fn add_bind(&mut self, src: &str, bind: Name, diag: &mut Diagnostics) { if let Some(old) = self.binds.get(&bind) { let warn = format!("The import '{src}' shadows the imported name '{old}'"); diag.add_book_warning(warn, WarningType::ImportShadow); } self.binds.insert(bind, Name::new(src)); } fn add_aliased_bind(&mut self, src: &Name, sub: &Name, alias: Option<&Name>, diag: &mut Diagnostics) { let src = format!("{}/{}", src, sub); let aliased = alias.unwrap_or(sub); self.add_bind(&src, aliased.clone(), diag); } fn add_binds(&mut self, names: &IndexSet, src: &Name, diag: &mut Diagnostics) { for sub in names { self.add_aliased_bind(src, sub, None, diag); } } /// Adds all names to the ImportMap in the form `alias/name`. /// If one of the names is equal to the file name, adds as `alias` instead. fn add_file_nested_binds( &mut self, src: &Name, file: &Name, alias: Option<&Name>, names: IndexSet, diag: &mut Diagnostics, ) { let aliased = alias.unwrap_or(file); self.add_nested_binds(src, aliased, names.iter().filter(|&n| n != file), diag); if names.contains(file) { let src = format!("{}/{}", src, file); self.add_bind(&src, aliased.clone(), diag); } } /// Adds all names to the ImportMap in the form `bind/name`. fn add_nested_binds<'a>( &mut self, src: &Name, bind: &Name, names: impl Iterator, diag: &mut Diagnostics, ) { for name in names { let src = format!("{}/{}", src, name); let bind = Name::new(format!("{bind}/{name}")); self.add_bind(&src, bind, diag); } } } ================================================ FILE: src/imports/packages.rs ================================================ use super::{loader::PackageLoader, normalize_path, BoundSource, ImportCtx, ImportType, ImportsMap}; use crate::{ diagnostics::Diagnostics, fun::{load_book::do_parse_book, parser::ParseBook, Name}, }; use indexmap::{IndexMap, IndexSet}; use std::{cell::RefCell, collections::VecDeque, path::PathBuf}; #[derive(Default)] pub struct Packages { /// Map from source name to parsed book. pub books: IndexMap>, /// Already loaded ADTs information to be used when applying ADT binds. /// Source path -> ADT names -> constructor names. pub loaded_adts: IndexMap>>, /// Queue of books indexes that still needs to load its imports. load_queue: VecDeque, } impl Packages { pub fn new(book: ParseBook) -> Self { Self { books: IndexMap::from([(book.source.clone(), book.into())]), load_queue: VecDeque::new(), loaded_adts: IndexMap::new(), } } /// Loads each import statement recursively into a Source -> ParseBook map. /// Inserts into the ImportsMap of each book all the imported names. pub fn load_imports( &mut self, loader: &mut impl PackageLoader, diag: &mut Diagnostics, ) -> Result { self.load_imports_go(0, None, loader)?; while let Some(idx) = self.load_queue.pop_front() { let parent_dir = { let book = self.books[idx].borrow(); book.source.rsplit_once('/').map(|(s, _)| Name::new(s)) }; self.load_imports_go(idx, parent_dir, loader)?; } for idx in 0..self.books.len() { self.load_binds(idx, diag); } let (_, book) = self.books.swap_remove_index(0).unwrap(); diag.fatal(book.into_inner()) } fn load_imports_go( &mut self, idx: usize, dir: Option, loader: &mut impl PackageLoader, ) -> Result<(), Diagnostics> { let mut sources = IndexMap::new(); { let mut book = self.books[idx].borrow_mut(); let names = &mut book.import_ctx.imports; for import in names { if import.relative { if let Some(ref dir) = dir { let path = format!("{}/{}", dir, import.path); let normalized = normalize_path(&PathBuf::from(path)); import.path = Name::new(normalized.to_string_lossy()); } } let loaded = loader.load(import)?; sources.extend(loaded); } } for (psrc, code) in sources { let module = do_parse_book(&code, &PathBuf::from(psrc.as_ref()), ParseBook::default())?; self.load_queue.push_back(self.books.len()); self.books.insert(psrc, module.into()); } Ok(()) } /// Maps the `ImportType` of each import to the top level names it relates, /// checks if it is valid, resolves `BoundSource::Either`, and adds to the book ImportMap. fn load_binds(&mut self, idx: usize, diag: &mut Diagnostics) { let book = &mut self.books[idx].borrow_mut(); let ImportCtx { imports, map } = &mut book.import_ctx; for import in imports { match (&mut import.src, &import.imp_type) { (BoundSource::Either(src, pkgs), ImportType::Single(nam, alias)) => { if self.unique_top_level_names(src).contains(nam) { let err = format!("Both file '{src}.bend' and folder '{src}' contains the import '{nam}'"); diag.add_book_error(err); continue; } self.add_file_from_dir(pkgs, nam, alias, map, diag); import.src = BoundSource::Dir(std::mem::take(pkgs)); } (BoundSource::Either(src, pkgs), ImportType::List(names)) => { for (name, alias) in names { let added = self.add_file_from_dir(pkgs, name, alias, map, diag); if !added { if !self.unique_top_level_names(src).contains(name) { let err = format!("Package '{src}' does not contain the top level name '{name}'"); diag.add_book_error(err); continue; } pkgs.insert(name.clone(), src.clone()); self.add_aliased_bind(src, name, alias, map, diag); } } import.src = BoundSource::Dir(std::mem::take(pkgs)); } (BoundSource::Either(src, pkgs), ImportType::Glob) => { let names = self.unique_top_level_names(src); let mut error = false; for nam in pkgs.keys() { if names.contains(nam) { let err = format!("Both file '{src}.bend' and folder '{src}' contains the import '{nam}'"); diag.add_book_error(err); error = true; } } if error { continue; } self.add_glob_from_dir(pkgs, map, diag); for sub in &names { pkgs.insert(sub.clone(), src.clone()); } map.add_binds(&names, src, diag); import.src = BoundSource::Dir(std::mem::take(pkgs)); } (BoundSource::File(src), ImportType::Single(name, alias)) => { if !self.unique_top_level_names(src).contains(name) { let err = format!("Package '{src}' does not contain the top level name '{name}'"); diag.add_book_error(err); continue; } self.add_aliased_bind(src, name, alias, map, diag); } (BoundSource::File(src), ImportType::List(names)) => { let src_names = self.unique_top_level_names(src); let mut error = false; for (sub, _) in names { if !src_names.contains(sub) { let err = format!("Package '{src}' does not contain the top level name '{sub}'"); diag.add_book_error(err); error = true; } } if error { continue; } for (name, alias) in names { self.add_aliased_bind(src, name, alias, map, diag); } } (BoundSource::File(src), ImportType::Glob) => { let names = self.unique_top_level_names(src); map.add_binds(&names, src, diag); } (BoundSource::Dir(pkgs), ImportType::Single(nam, alias)) => { self.add_file_from_dir(pkgs, nam, alias, map, diag); } (BoundSource::Dir(pkgs), ImportType::List(names)) => { for (nam, alias) in names { self.add_file_from_dir(pkgs, nam, alias, map, diag); } } (BoundSource::Dir(pkgs), ImportType::Glob) => { self.add_glob_from_dir(pkgs, map, diag); } (BoundSource::None, _) => unreachable!(), } } } fn add_aliased_bind( &self, src: &mut Name, name: &Name, alias: &Option, map: &mut ImportsMap, diag: &mut Diagnostics, ) { let alias = alias.as_ref(); if let Some(adt) = self.books.get(src).unwrap().borrow().adts.get(name) { let names = adt.ctrs.iter().map(|(n, _)| n); map.add_nested_binds(src, alias.unwrap_or(name), names, diag); } map.add_aliased_bind(src, name, alias, diag); } fn add_file_from_dir( &self, pkgs: &IndexMap, nam: &Name, alias: &Option, map: &mut ImportsMap, diag: &mut Diagnostics, ) -> bool { if let Some(src) = pkgs.get(nam) { let names = self.unique_top_level_names(src); map.add_file_nested_binds(src, nam, alias.as_ref(), names, diag); true } else { false } } fn add_glob_from_dir(&self, pkgs: &IndexMap, map: &mut ImportsMap, diag: &mut Diagnostics) { for (nam, src) in pkgs { let names = self.unique_top_level_names(src); map.add_file_nested_binds(src, nam, None, names, diag); } } fn unique_top_level_names(&self, src: &Name) -> IndexSet { let bound_book = self.books.get(src).unwrap().borrow(); bound_book.top_level_names().cloned().collect() } } ================================================ FILE: src/lib.rs ================================================ use crate::{ fun::{book_to_hvm, net_to_term::net_to_term, term_to_net::Labels, Book, Ctx, Term}, hvm::{ add_recursive_priority::add_recursive_priority, check_net_size::{check_net_sizes, MAX_NET_SIZE_CUDA}, eta_reduce::eta_reduce_hvm_net, hvm_book_show_pretty, inline::inline_hvm_book, mutual_recursion, prune::prune_hvm_book, }, }; use diagnostics::{Diagnostics, DiagnosticsConfig, ERR_INDENT_SIZE}; use net::hvm_to_net::hvm_to_net; pub mod diagnostics; // `Name` triggers this warning, but it's safe because we're not using its internal mutability. #[allow(clippy::mutable_key_type)] pub mod fun; pub mod hvm; pub mod imp; pub mod imports; pub mod net; mod utils; pub use fun::load_book::{load_file_to_book, load_to_book}; pub const ENTRY_POINT: &str = "main"; pub const HVM1_ENTRY_POINT: &str = "Main"; pub const HVM_OUTPUT_END_MARKER: &str = "Result: "; pub fn check_book( book: &mut Book, diagnostics_cfg: DiagnosticsConfig, compile_opts: CompileOpts, ) -> Result { // TODO: Do the checks without having to do full compilation let res = compile_book(book, compile_opts, diagnostics_cfg, None)?; Ok(res.diagnostics) } pub fn compile_book( book: &mut Book, opts: CompileOpts, diagnostics_cfg: DiagnosticsConfig, args: Option>, ) -> Result { let mut diagnostics = desugar_book(book, opts.clone(), diagnostics_cfg, args)?; let (mut hvm_book, labels) = book_to_hvm(book, &mut diagnostics)?; if opts.eta { hvm_book.defs.values_mut().for_each(eta_reduce_hvm_net); } mutual_recursion::check_cycles(&hvm_book, &mut diagnostics)?; if opts.eta { hvm_book.defs.values_mut().for_each(eta_reduce_hvm_net); } if opts.inline { if let Err(e) = inline_hvm_book(&mut hvm_book) { diagnostics.add_book_error(format!("During inlining:\n{:ERR_INDENT_SIZE$}{}", "", e)); } diagnostics.fatal(())?; } if opts.prune { let prune_entrypoints = vec![book.hvm_entrypoint().to_string()]; prune_hvm_book(&mut hvm_book, &prune_entrypoints); } if opts.check_net_size { check_net_sizes(&hvm_book, &mut diagnostics, &opts.target_architecture)?; } add_recursive_priority(&mut hvm_book); Ok(CompileResult { hvm_book, labels, diagnostics }) } pub fn desugar_book( book: &mut Book, opts: CompileOpts, diagnostics_cfg: DiagnosticsConfig, args: Option>, ) -> Result { let mut ctx = Ctx::new(book, diagnostics_cfg); ctx.check_shared_names(); ctx.set_entrypoint(); ctx.book.encode_adts(opts.adt_encoding); ctx.fix_match_defs()?; ctx.apply_args(args)?; ctx.desugar_open()?; ctx.book.encode_builtins(); ctx.resolve_refs()?; ctx.desugar_match_defs()?; ctx.fix_match_terms()?; ctx.book.lift_local_defs(); ctx.desugar_bend()?; ctx.desugar_fold()?; ctx.desugar_with_blocks()?; ctx.check_unbound_vars()?; // Auto match linearization ctx.book.make_var_names_unique(); ctx.book.desugar_use(); match opts.linearize_matches { OptLevel::Disabled => (), OptLevel::Alt => ctx.book.linearize_match_binds(), OptLevel::Enabled => ctx.book.linearize_matches(), } // Manual match linearization ctx.book.linearize_match_with(); if opts.type_check { type_check_book(&mut ctx)?; } ctx.book.encode_matches(opts.adt_encoding); // sanity check ctx.check_unbound_vars()?; ctx.book.make_var_names_unique(); ctx.book.desugar_use(); ctx.book.make_var_names_unique(); ctx.book.linearize_vars(); // sanity check ctx.check_unbound_vars()?; if opts.float_combinators { ctx.book.float_combinators(MAX_NET_SIZE_CUDA); } // sanity check ctx.check_unbound_refs()?; // Optimizing passes ctx.prune(opts.prune); if opts.merge { ctx.book.merge_definitions(); } ctx.book.expand_main(); ctx.book.make_var_names_unique(); if !ctx.info.has_errors() { Ok(ctx.info) } else { Err(ctx.info) } } pub fn type_check_book(ctx: &mut Ctx) -> Result<(), Diagnostics> { ctx.check_untyped_terms()?; ctx.resolve_type_ctrs()?; ctx.type_check()?; Ok(()) } pub fn run_book( mut book: Book, run_opts: RunOpts, compile_opts: CompileOpts, diagnostics_cfg: DiagnosticsConfig, args: Option>, cmd: &str, ) -> Result, Diagnostics> { let CompileResult { hvm_book: core_book, labels, diagnostics } = compile_book(&mut book, compile_opts.clone(), diagnostics_cfg, args)?; // TODO: Printing should be taken care by the cli module, but we'd // like to print any warnings before running so that the user can // cancel the run if a problem is detected. eprint!("{diagnostics}"); let out = run_hvm(&core_book, cmd, &run_opts)?; let (net, stats) = parse_hvm_output(&out)?; let (term, diags) = readback_hvm_net(&net, &book, &labels, run_opts.linear_readback, compile_opts.adt_encoding); Ok(Some((term, stats, diags))) } pub fn readback_hvm_net( net: &::hvm::ast::Net, book: &Book, labels: &Labels, linear: bool, adt_encoding: AdtEncoding, ) -> (Term, Diagnostics) { let mut diags = Diagnostics::default(); let net = hvm_to_net(net); let mut term = net_to_term(&net, book, labels, linear, &mut diags); #[allow(clippy::mutable_key_type)] // Safe to allow, we know how `Name` works. let recursive_defs = book.recursive_defs(); term.expand_generated(book, &recursive_defs); term.resugar_strings(adt_encoding); term.resugar_lists(adt_encoding); (term, diags) } /// Runs an HVM book by invoking HVM as a subprocess. fn run_hvm(book: &::hvm::ast::Book, cmd: &str, run_opts: &RunOpts) -> Result { let out_path = ".out.hvm"; std::fs::write(out_path, hvm_book_show_pretty(book)).map_err(|x| x.to_string())?; let mut process = std::process::Command::new(run_opts.hvm_path.clone()) .arg(cmd) .arg(out_path) .stdout(std::process::Stdio::piped()) .stderr(std::process::Stdio::inherit()) .spawn() .map_err(|e| format!("Failed to start hvm process.\n{e}"))?; let child_out = std::mem::take(&mut process.stdout).expect("Failed to attach to hvm output"); let thread_out = std::thread::spawn(move || filter_hvm_output(child_out, std::io::stdout())); let _ = process.wait().expect("Failed to wait on hvm subprocess"); if let Err(e) = std::fs::remove_file(out_path) { eprintln!("Error removing HVM output file. {e}"); } let result = thread_out.join().map_err(|_| "HVM output thread panicked.".to_string())??; Ok(result) } /// Reads the final output from HVM and separates the extra information. fn parse_hvm_output(out: &str) -> Result<(::hvm::ast::Net, String), String> { let Some((result, stats)) = out.split_once('\n') else { return Err(format!( "Failed to parse result from HVM (unterminated result).\nOutput from HVM was:\n{:?}", out )); }; let mut p = ::hvm::ast::CoreParser::new(result); let Ok(net) = p.parse_net() else { return Err(format!("Failed to parse result from HVM (invalid net).\nOutput from HVM was:\n{:?}", out)); }; Ok((net, stats.to_string())) } /// Filters the output from HVM, separating user output from the /// result, used for readback and displaying stats. /// /// Buffers the output from HVM to try to parse it. fn filter_hvm_output( mut stream: impl std::io::Read + Send, mut output: impl std::io::Write + Send, ) -> Result { let mut capturing = false; let mut result = String::new(); let mut buf = [0u8; 1024]; loop { let num_read = match stream.read(&mut buf) { Ok(n) => n, Err(e) => { eprintln!("{e}"); break; } }; if num_read == 0 { break; } let new_buf = &buf[..num_read]; // TODO: Does this lead to broken characters if printing too much at once? let new_str = String::from_utf8_lossy(new_buf); if capturing { // Store the result result.push_str(&new_str); } else if let Some((before, after)) = new_str.split_once(HVM_OUTPUT_END_MARKER) { // If result started in the middle of the buffer, print what came before and start capturing. if let Err(e) = output.write_all(before.as_bytes()) { eprintln!("Error writing HVM output. {e}"); }; result.push_str(after); capturing = true; } else { // Otherwise, don't capture anything if let Err(e) = output.write_all(new_buf) { eprintln!("Error writing HVM output. {e}"); } } } if capturing { Ok(result) } else { output.flush().map_err(|e| format!("Error flushing HVM output. {e}"))?; let msg = "HVM output had no result (An error likely occurred)".to_string(); Err(msg) } } #[derive(Clone, Debug)] pub struct RunOpts { pub linear_readback: bool, pub pretty: bool, pub hvm_path: String, } impl Default for RunOpts { fn default() -> Self { RunOpts { linear_readback: false, pretty: false, hvm_path: "hvm".to_string() } } } #[derive(Clone, Copy, Debug, Default)] pub enum OptLevel { Disabled, #[default] Enabled, Alt, } impl OptLevel { pub fn enabled(&self) -> bool { !matches!(self, OptLevel::Disabled) } pub fn is_extra(&self) -> bool { matches!(self, OptLevel::Enabled) } } #[derive(Clone, Debug, PartialEq, Eq)] pub enum CompilerTarget { C, Cuda, Unknown, } #[derive(Clone, Debug)] pub struct CompileOpts { /// The Compiler target architecture pub target_architecture: CompilerTarget, /// Enables [hvm::eta_reduce]. pub eta: bool, /// Enables [fun::transform::definition_pruning] and [hvm::prune]. pub prune: bool, /// Enables [fun::transform::linearize_matches]. pub linearize_matches: OptLevel, /// Enables [fun::transform::float_combinators]. pub float_combinators: bool, /// Enables [fun::transform::definition_merge] pub merge: bool, /// Enables [hvm::inline]. pub inline: bool, /// Enables [hvm::check_net_size]. pub check_net_size: bool, /// Enables [type_check_book]. pub type_check: bool, /// Determines the encoding of constructors and matches. pub adt_encoding: AdtEncoding, } impl CompileOpts { /// Set all optimizing options as true #[must_use] pub fn set_all(self) -> Self { Self { target_architecture: self.target_architecture, eta: true, prune: true, float_combinators: true, merge: true, linearize_matches: OptLevel::Enabled, type_check: true, inline: true, check_net_size: self.check_net_size, adt_encoding: self.adt_encoding, } } /// Set all optimizing options as false #[must_use] pub fn set_no_all(self) -> Self { Self { target_architecture: self.target_architecture, eta: false, prune: false, linearize_matches: OptLevel::Disabled, float_combinators: false, merge: false, inline: false, type_check: self.type_check, check_net_size: self.check_net_size, adt_encoding: self.adt_encoding, } } pub fn check_for_strict(&self) { if !self.float_combinators { println!( "Warning: Running in strict mode without enabling the float_combinators pass can lead to some functions expanding infinitely." ); } if !self.linearize_matches.enabled() { println!( "Warning: Running in strict mode without enabling the linearize_matches pass can lead to some functions expanding infinitely." ); } } } impl Default for CompileOpts { /// Enables eta, linearize_matches, float_combinators. /// Uses num-scott ADT encoding. fn default() -> Self { Self { target_architecture: CompilerTarget::Unknown, eta: true, prune: false, linearize_matches: OptLevel::Enabled, float_combinators: true, merge: false, inline: false, check_net_size: true, type_check: true, adt_encoding: AdtEncoding::NumScott, } } } #[derive(Clone, Copy, Debug)] pub enum AdtEncoding { Scott, NumScott, } impl std::fmt::Display for AdtEncoding { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { AdtEncoding::Scott => write!(f, "Scott"), AdtEncoding::NumScott => write!(f, "NumScott"), } } } pub struct CompileResult { pub diagnostics: Diagnostics, pub hvm_book: ::hvm::ast::Book, pub labels: Labels, } fn maybe_grow(f: F) -> R where F: FnOnce() -> R, { stacker::maybe_grow(1024 * 32, 1024 * 1024, f) } ================================================ FILE: src/main.rs ================================================ use bend::{ check_book, compile_book, desugar_book, diagnostics::{Diagnostics, DiagnosticsConfig, Severity}, fun::{Book, Name}, hvm::hvm_book_show_pretty, imports::DefaultLoader, load_file_to_book, run_book, AdtEncoding, CompileOpts, CompilerTarget, OptLevel, RunOpts, }; use clap::{Args, CommandFactory, Parser, Subcommand}; use std::{ path::{Path, PathBuf}, process::ExitCode, }; #[derive(Parser, Debug)] #[command(author, version, about, long_about = None)] struct Cli { #[command(subcommand)] pub mode: Mode, #[arg(short, long, global = true)] pub verbose: bool, #[arg(long, global = true, help = "HVM command or path to HVM binary")] pub hvm_bin: Option, #[arg(short = 'e', long, global = true, help = "Use other entrypoint rather than main or Main")] pub entrypoint: Option, } #[derive(Subcommand, Clone, Debug)] enum Mode { /// Checks that the program is syntactically and semantically correct. Check { #[arg( short = 'O', value_delimiter = ' ', action = clap::ArgAction::Append, long_help = r#"Enables or disables the given optimizations float_combinators is enabled by default on strict mode."#, )] comp_opts: Vec, #[command(flatten)] warn_opts: CliWarnOpts, #[arg(help = "Path to the input file")] path: PathBuf, }, /// Compiles the program and runs it with the Rust HVM implementation. RunRs(RunArgs), /// Compiles the program and runs it with the C HVM implementation. #[command(alias = "run")] RunC(RunArgs), /// Compiles the program and runs it with the Cuda HVM implementation. RunCu(RunArgs), /// Compiles the program to hvm and prints to stdout. GenHvm(GenArgs), /// Compiles the program to standalone C and prints to stdout. GenC(GenArgs), /// Compiles the program to standalone Cuda and prints to stdout. GenCu(GenArgs), /// Runs the lambda-term level desugaring passes. Desugar { #[arg( short = 'O', value_delimiter = ' ', action = clap::ArgAction::Append, long_help = r#"Enables or disables the given optimizations float_combinators is enabled by default on strict mode."#, )] comp_opts: Vec, #[arg(short = 'p', help = "Debug and normalization pretty printing")] pretty: bool, #[command(flatten)] warn_opts: CliWarnOpts, #[arg(help = "Path to the input file")] path: PathBuf, }, } #[derive(Args, Clone, Debug)] struct RunArgs { #[arg(short = 'p', help = "Debug and normalization pretty printing")] pretty: bool, #[command(flatten)] run_opts: CliRunOpts, #[arg( short = 'O', value_delimiter = ' ', action = clap::ArgAction::Append, long_help = r#"Enables or disables the given optimizations float_combinators is enabled by default on strict mode."#, )] comp_opts: Vec, #[command(flatten)] warn_opts: CliWarnOpts, #[arg(help = "Path to the input file")] path: PathBuf, #[arg(value_parser = |arg: &str| bend::fun::parser::FunParser::new(Name::new(""), arg, false).parse_term())] arguments: Option>, } #[derive(Args, Clone, Debug)] struct GenArgs { #[arg( short = 'O', value_delimiter = ' ', action = clap::ArgAction::Append, long_help = r#"Enables or disables the given optimizations float_combinators is enabled by default on strict mode."#, )] comp_opts: Vec, #[command(flatten)] warn_opts: CliWarnOpts, #[arg(help = "Path to the input file")] path: PathBuf, } #[derive(Args, Clone, Debug)] struct CliRunOpts { #[arg(short = 'l', help = "Linear readback (show explicit dups)")] linear: bool, #[arg(short = 's', long = "stats", help = "Shows runtime stats and rewrite counts")] print_stats: bool, } #[derive(Args, Debug, Clone)] #[group(multiple = true)] struct CliWarnOpts { #[arg( short = 'W', long = "warn", value_delimiter = ' ', action = clap::ArgAction::Append, help = "Show the specified compilation warning", )] pub warns: Vec, #[arg( short = 'D', long = "deny", value_delimiter = ' ', action = clap::ArgAction::Append, help = "Deny the specified compilation warning", )] pub denies: Vec, #[arg( short = 'A', long = "allow", value_delimiter = ' ', action = clap::ArgAction::Append, help = "Allow the specified compilation warning", )] pub allows: Vec, } #[derive(clap::ValueEnum, Clone, Debug)] pub enum OptArgs { All, NoAll, Eta, NoEta, Prune, NoPrune, LinearizeMatches, LinearizeMatchesAlt, NoLinearizeMatches, FloatCombinators, NoFloatCombinators, Merge, NoMerge, Inline, NoInline, CheckNetSize, NoCheckNetSize, AdtScott, AdtNumScott, TypeCheck, NoTypeCheck, } fn compile_opts_from_cli(args: &Vec, compiler_target: CompilerTarget) -> CompileOpts { use OptArgs::*; let mut opts = CompileOpts { target_architecture: compiler_target, ..CompileOpts::default() }; if opts.target_architecture != CompilerTarget::C { opts.eta = false; } for arg in args { match arg { All => opts = opts.set_all(), NoAll => opts = opts.set_no_all(), Eta => opts.eta = true, NoEta => opts.eta = false, Prune => opts.prune = true, NoPrune => opts.prune = false, FloatCombinators => opts.float_combinators = true, NoFloatCombinators => opts.float_combinators = false, Merge => opts.merge = true, NoMerge => opts.merge = false, Inline => opts.inline = true, NoInline => opts.inline = false, CheckNetSize => opts.check_net_size = true, NoCheckNetSize => opts.check_net_size = false, TypeCheck => opts.type_check = true, NoTypeCheck => opts.type_check = false, LinearizeMatches => opts.linearize_matches = OptLevel::Enabled, LinearizeMatchesAlt => opts.linearize_matches = OptLevel::Alt, NoLinearizeMatches => opts.linearize_matches = OptLevel::Disabled, AdtScott => opts.adt_encoding = AdtEncoding::Scott, AdtNumScott => opts.adt_encoding = AdtEncoding::NumScott, } } opts } #[derive(clap::ValueEnum, Clone, Debug)] pub enum WarningArgs { All, IrrefutableMatch, RedundantMatch, UnreachableMatch, UnusedDefinition, RepeatedBind, RecursionCycle, ImportShadow, MissingMain, } fn main() -> ExitCode { #[cfg(not(feature = "cli"))] compile_error!("The 'cli' feature is needed for the Bend cli"); let cli = Cli::parse(); if let Err(diagnostics) = execute_cli_mode(cli) { eprint!("{diagnostics}"); return ExitCode::FAILURE; } ExitCode::SUCCESS } fn execute_cli_mode(mut cli: Cli) -> Result<(), Diagnostics> { let arg_verbose = cli.verbose; let entrypoint = cli.entrypoint.take(); let load_book = |path: &Path, diag: DiagnosticsConfig| -> Result { let package_loader = DefaultLoader::new(path); let mut book = load_file_to_book(path, package_loader, diag)?; book.entrypoint = entrypoint.map(Name::new); if arg_verbose { println!("{book}"); } Ok(book) }; // Path/command for the HVM binary // CLI option -> Env var -> Default let hvm_bin = if let Some(hvm_bin) = cli.hvm_bin { hvm_bin } else if let Ok(hvm_bin) = std::env::var("HVM_BIN") { hvm_bin } else { "hvm".to_string() }; let gen_cmd = match &cli.mode { Mode::GenC(..) => "gen-c", Mode::GenCu(..) => "gen-cu", _ => "gen", }; let run_cmd = match &cli.mode { Mode::RunC(..) => "run-c", Mode::RunRs(..) => "run", Mode::RunCu(..) => "run-cu", _ => "run-c", }; let compiler_target = match &cli.mode { Mode::RunC(..) => CompilerTarget::C, Mode::GenC(..) => CompilerTarget::C, Mode::RunCu(..) => CompilerTarget::Cuda, Mode::GenCu(..) => CompilerTarget::Cuda, _ => CompilerTarget::Unknown, }; match cli.mode { Mode::Check { comp_opts, warn_opts, path } => { let diagnostics_cfg = set_warning_cfg_from_cli(DiagnosticsConfig::default(), warn_opts); let compile_opts = compile_opts_from_cli(&comp_opts, compiler_target); let mut book = load_book(&path, diagnostics_cfg)?; let diagnostics = check_book(&mut book, diagnostics_cfg, compile_opts)?; eprintln!("{}", diagnostics); } Mode::GenHvm(GenArgs { comp_opts, warn_opts, path, .. }) => { let diagnostics_cfg = set_warning_cfg_from_cli(DiagnosticsConfig::default(), warn_opts); let opts = compile_opts_from_cli(&comp_opts, compiler_target); let mut book = load_book(&path, diagnostics_cfg)?; let compile_res = compile_book(&mut book, opts, diagnostics_cfg, None)?; eprint!("{}", compile_res.diagnostics); println!("{}", hvm_book_show_pretty(&compile_res.hvm_book)); } Mode::RunC(RunArgs { pretty, run_opts, comp_opts, warn_opts, path, arguments }) | Mode::RunCu(RunArgs { pretty, run_opts, comp_opts, warn_opts, path, arguments }) | Mode::RunRs(RunArgs { pretty, run_opts, comp_opts, warn_opts, path, arguments }) => { let CliRunOpts { linear, print_stats } = run_opts; let diagnostics_cfg = set_warning_cfg_from_cli(DiagnosticsConfig::new(Severity::Allow, arg_verbose), warn_opts); let compile_opts = compile_opts_from_cli(&comp_opts, compiler_target); compile_opts.check_for_strict(); let run_opts = RunOpts { linear_readback: linear, pretty, hvm_path: hvm_bin }; let book = load_book(&path, diagnostics_cfg)?; if let Some((term, stats, diags)) = run_book(book, run_opts, compile_opts, diagnostics_cfg, arguments, run_cmd)? { eprint!("{diags}"); if pretty { println!("Result:\n{}", term.display_pretty(0)); } else { println!("Result: {}", term); } if print_stats { println!("{stats}"); } } } Mode::GenC(GenArgs { comp_opts, warn_opts, path }) | Mode::GenCu(GenArgs { comp_opts, warn_opts, path }) => { let diagnostics_cfg = set_warning_cfg_from_cli(DiagnosticsConfig::default(), warn_opts); let opts = compile_opts_from_cli(&comp_opts, compiler_target); let mut book = load_book(&path, diagnostics_cfg)?; let compile_res = compile_book(&mut book, opts, diagnostics_cfg, None)?; let out_path = ".out.hvm"; std::fs::write(out_path, hvm_book_show_pretty(&compile_res.hvm_book)).map_err(|x| x.to_string())?; let gen_fn = |out_path: &str| { let mut process = std::process::Command::new(hvm_bin); process.arg(gen_cmd).arg(out_path); process.output().map_err(|e| format!("While running hvm: {e}")) }; let std::process::Output { stdout, stderr, status } = gen_fn(out_path)?; let out = String::from_utf8_lossy(&stdout); let err = String::from_utf8_lossy(&stderr); let status = if !status.success() { status.to_string() } else { String::new() }; if let Err(e) = std::fs::remove_file(out_path) { eprintln!("Error removing HVM output file. {e}"); } eprintln!("{err}"); println!("{out}"); println!("{status}"); } Mode::Desugar { path, comp_opts, warn_opts, pretty } => { let diagnostics_cfg = set_warning_cfg_from_cli(DiagnosticsConfig::default(), warn_opts); let opts = compile_opts_from_cli(&comp_opts, compiler_target); let mut book = load_book(&path, diagnostics_cfg)?; let diagnostics = desugar_book(&mut book, opts, diagnostics_cfg, None)?; eprint!("{diagnostics}"); if pretty { println!("{}", book.display_pretty()) } else { println!("{book}"); } } }; Ok(()) } fn set_warning_cfg_from_cli(mut cfg: DiagnosticsConfig, warn_opts: CliWarnOpts) -> DiagnosticsConfig { fn set(cfg: &mut DiagnosticsConfig, severity: Severity, cli_val: WarningArgs) { match cli_val { WarningArgs::All => { cfg.irrefutable_match = severity; cfg.redundant_match = severity; cfg.unreachable_match = severity; cfg.unused_definition = severity; cfg.repeated_bind = severity; cfg.recursion_cycle = severity; cfg.import_shadow = severity; } WarningArgs::IrrefutableMatch => cfg.irrefutable_match = severity, WarningArgs::RedundantMatch => cfg.redundant_match = severity, WarningArgs::UnreachableMatch => cfg.unreachable_match = severity, WarningArgs::UnusedDefinition => cfg.unused_definition = severity, WarningArgs::RepeatedBind => cfg.repeated_bind = severity, WarningArgs::RecursionCycle => cfg.recursion_cycle = severity, WarningArgs::ImportShadow => cfg.import_shadow = severity, WarningArgs::MissingMain => cfg.missing_main = severity, // TODO: Should `WarningArgs::All` modify this as well? } } let cmd = Cli::command(); let matches = cmd.get_matches(); let subcmd_name = matches.subcommand_name().expect("To have a subcommand"); let arg_matches = matches.subcommand_matches(subcmd_name).expect("To have a subcommand"); if let Some(warn_opts_ids) = arg_matches.get_many::("CliWarnOpts") { let mut allows = warn_opts.allows.into_iter(); let mut warns = warn_opts.warns.into_iter(); let mut denies = warn_opts.denies.into_iter(); for id in warn_opts_ids { match id.as_ref() { "allows" => set(&mut cfg, Severity::Allow, allows.next().unwrap()), "denies" => set(&mut cfg, Severity::Error, denies.next().unwrap()), "warns" => set(&mut cfg, Severity::Warning, warns.next().unwrap()), _ => unreachable!(), } } } cfg } ================================================ FILE: src/net/hvm_to_net.rs ================================================ use super::{INet, INode, INodes, NodeId, NodeKind::*, Port, SlotId, ROOT}; use crate::{ fun::Name, net::{CtrKind, NodeKind}, }; use hvm::ast::{Net, Tree}; pub fn hvm_to_net(net: &Net) -> INet { let inodes = hvm_to_inodes(net); inodes_to_inet(&inodes) } fn hvm_to_inodes(net: &Net) -> INodes { let mut inodes = vec![]; let mut n_vars = 0; let net_root = if let Tree::Var { nam } = &net.root { nam } else { "" }; // If we have a tree attached to the net root, convert that first if !matches!(&net.root, Tree::Var { .. }) { let mut root = tree_to_inodes(&net.root, "_".to_string(), net_root, &mut n_vars); inodes.append(&mut root); } // Convert all the trees forming active pairs. for (i, (_, tree1, tree2)) in net.rbag.iter().enumerate() { // This name cannot appear anywhere in the original net let tree_root = format!("%a{i}"); let mut tree1 = tree_to_inodes(tree1, tree_root.clone(), net_root, &mut n_vars); inodes.append(&mut tree1); let mut tree2 = tree_to_inodes(tree2, tree_root, net_root, &mut n_vars); inodes.append(&mut tree2); } inodes } fn new_var(n_vars: &mut NodeId) -> String { // This name cannot appear anywhere in the original net let new_var = format!("%x{n_vars}"); *n_vars += 1; new_var } fn tree_to_inodes(tree: &Tree, tree_root: String, net_root: &str, n_vars: &mut NodeId) -> INodes { fn process_node_subtree<'a>( subtree: &'a Tree, net_root: &str, subtrees: &mut Vec<(String, &'a Tree)>, n_vars: &mut NodeId, ) -> String { if let Tree::Var { nam } = subtree { if nam == net_root { "_".to_string() } else { nam.clone() } } else { let var = new_var(n_vars); subtrees.push((var.clone(), subtree)); var } } let mut inodes = vec![]; let mut subtrees = vec![(tree_root, tree)]; while let Some((subtree_root, subtree)) = subtrees.pop() { match subtree { Tree::Era => { let var = new_var(n_vars); inodes.push(INode { kind: Era, ports: [subtree_root, var.clone(), var] }); } Tree::Con { fst, snd } => { let kind = NodeKind::Ctr(CtrKind::Con(None)); let fst = process_node_subtree(fst, net_root, &mut subtrees, n_vars); let snd = process_node_subtree(snd, net_root, &mut subtrees, n_vars); inodes.push(INode { kind, ports: [subtree_root, fst, snd] }); } Tree::Dup { fst, snd } => { let kind = NodeKind::Ctr(CtrKind::Dup(0)); let fst = process_node_subtree(fst, net_root, &mut subtrees, n_vars); let snd = process_node_subtree(snd, net_root, &mut subtrees, n_vars); inodes.push(INode { kind, ports: [subtree_root, fst, snd] }); } Tree::Var { .. } => unreachable!(), Tree::Ref { nam } => { let kind = Ref { def_name: Name::new(nam) }; let var = new_var(n_vars); inodes.push(INode { kind, ports: [subtree_root, var.clone(), var] }); } Tree::Num { val } => { let kind = Num { val: val.0 }; let var = new_var(n_vars); inodes.push(INode { kind, ports: [subtree_root, var.clone(), var] }); } Tree::Opr { fst, snd } => { let kind = NodeKind::Opr; let fst = process_node_subtree(fst, net_root, &mut subtrees, n_vars); let snd = process_node_subtree(snd, net_root, &mut subtrees, n_vars); inodes.push(INode { kind, ports: [subtree_root, fst, snd] }); } Tree::Swi { fst, snd } => { let kind = NodeKind::Swi; let fst = process_node_subtree(fst, net_root, &mut subtrees, n_vars); let snd = process_node_subtree(snd, net_root, &mut subtrees, n_vars); inodes.push(INode { kind, ports: [subtree_root, fst, snd] }); } } } inodes } // Converts INodes to an INet by linking ports based on names. fn inodes_to_inet(inodes: &INodes) -> INet { let mut inet = INet::new(); // Maps named inode ports to numeric inet ports. let mut name_map = std::collections::HashMap::new(); for inode in inodes { let node = inet.new_node(inode.kind.clone()); for (j, name) in inode.ports.iter().enumerate() { let p = Port(node, j as SlotId); if name == "_" { inet.link(p, ROOT); } else if let Some(&q) = name_map.get(name) { inet.link(p, q); name_map.remove(name); } else { name_map.insert(name.clone(), p); } } } inet } ================================================ FILE: src/net/mod.rs ================================================ pub mod hvm_to_net; use crate::fun::Name; pub type BendLab = u16; use NodeKind::*; #[derive(Debug, Clone)] /// Net representation used only as an intermediate for converting to hvm-core format pub struct INet { nodes: Vec, } #[derive(Debug, Clone)] pub struct Node { pub main: Port, pub aux1: Port, pub aux2: Port, pub kind: NodeKind, } #[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord, Default)] pub struct Port(pub NodeId, pub SlotId); #[derive(Debug, Clone, PartialEq, Eq)] pub enum NodeKind { /// Root node Rot, /// Erasure nodes Era, /// Binary combinators Ctr(CtrKind), /// Reference to function definitions Ref { def_name: Name }, /// Numbers Num { val: u32 }, /// Numeric operations Opr, /// Pattern matching on numbers Swi, } #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum CtrKind { Con(Option), Tup(Option), Dup(BendLab), } impl CtrKind { pub fn to_lab(self) -> BendLab { #[allow(clippy::identity_op)] match self { CtrKind::Con(None) => 0, CtrKind::Con(Some(_)) => todo!("Tagged lambdas/applications not implemented for hvm32"), CtrKind::Tup(None) => 0, CtrKind::Tup(Some(_)) => todo!("Tagged tuples not implemented for hvm32"), CtrKind::Dup(0) => 1, CtrKind::Dup(_) => todo!("Tagged dups/sups not implemented for hvm32"), } } } pub type NodeId = u64; pub type SlotId = u64; /// The ROOT port is on the deadlocked root node at address 0. pub const ROOT: Port = Port(0, 1); pub const TAG_WIDTH: u32 = 4; pub const TAG: u32 = u64::BITS - TAG_WIDTH; pub const LABEL_MASK: u64 = (1 << TAG) - 1; pub const TAG_MASK: u64 = !LABEL_MASK; impl INet { /// Create a new net, with a deadlocked root node. pub fn new() -> Self { Self::default() } /// Allocates a new node with its ports disconnected. pub fn new_node(&mut self, kind: NodeKind) -> NodeId { let idx = self.nodes.len() as NodeId; let node = Node::new(Port(idx, 0), Port(idx, 1), Port(idx, 2), kind); self.nodes.extend([node]); idx } /// Returns a reference to a node. pub fn node(&self, node: NodeId) -> &Node { &self.nodes[node as usize] } /// Returns the value stored at a port, the port on the other side of the given one. pub fn enter_port(&self, port: Port) -> Port { self.node(port.node_id()).port(port.slot()) } /// Links two ports. pub fn link(&mut self, a: Port, b: Port) { self.set(a, b); self.set(b, a); } /// Sets a port to point to another port pub fn set(&mut self, src: Port, dst: Port) { *self.nodes[src.node_id() as usize].port_mut(src.slot()) = dst; } } impl Default for INet { fn default() -> Self { INet { nodes: vec![Node::new(Port(0, 2), Port(0, 1), Port(0, 0), Rot)], // p2 points to p0, p1 points to net } } } impl Node { pub fn new(main: Port, aux1: Port, aux2: Port, kind: NodeKind) -> Self { Node { main, aux1, aux2, kind } } pub fn port(&self, slot: SlotId) -> Port { match slot { 0 => self.main, 1 => self.aux1, 2 => self.aux2, _ => unreachable!(), } } pub fn port_mut(&mut self, slot: SlotId) -> &mut Port { match slot { 0 => &mut self.main, 1 => &mut self.aux1, 2 => &mut self.aux2, _ => unreachable!(), } } } impl Port { /// Returns the node address of a port. pub fn node_id(self) -> NodeId { self.0 } /// Returns the slot of a port. pub fn slot(self) -> SlotId { self.1 } } /* INodes representation: */ /// A flat inet representation where links are represented by shared wire names. // TODO: Find a better name pub type INodes = Vec; #[derive(Debug)] pub struct INode { pub kind: NodeKind, pub ports: [String; 3], } ================================================ FILE: src/utils.rs ================================================ /// A macro for creating iterators that can have statically known /// different types. Useful for iterating over tree children, where /// each tree node variant yields a different iterator type. #[macro_export] macro_rules! multi_iterator { ($Iter:ident { $($Variant:ident),* $(,)? }) => { #[derive(Debug, Clone)] enum $Iter<$($Variant),*> { $($Variant { iter: $Variant }),* } impl<$($Variant),*> $Iter<$($Variant),*> { $( #[allow(non_snake_case)] fn $Variant(iter: impl IntoIterator) -> Self { $Iter::$Variant { iter: iter.into_iter() } } )* } impl),*> Iterator for $Iter<$($Variant),*> { type Item = T; fn next(&mut self) -> Option { match self { $($Iter::$Variant { iter } => iter.next()),* } } fn size_hint(&self) -> (usize, Option) { match self { $($Iter::$Variant { iter } => iter.size_hint()),* } } } impl),*> DoubleEndedIterator for $Iter<$($Variant),*> { fn next_back(&mut self) -> Option { match self { $($Iter::$Variant { iter } => iter.next_back()),* } } } }; } ================================================ FILE: tests/golden_tests/check_file/fail_type_bad_rec_fn_adt.bend ================================================ # Should give a type error in Erase when unifying the field of type Unit with the match type of Box type Box: Box {x: Unit} type Unit: Unit Erase: Box -> None (Erase (Box/Box x)) = (Erase x) main: None main = (Erase (Box/Box Unit/Unit)) ================================================ FILE: tests/golden_tests/check_file/non_exaustive_limit.bend ================================================ type Foo = A | B | C | D | E | F | G | H Bar Foo/A Foo/A Foo/A = * main = * ================================================ FILE: tests/golden_tests/check_file/type_err_match_arm.bend ================================================ type Nat_: Zero Succ {x: Unit, pred: Nat_} type Unit: Unit Test1: Nat_ -> (Nat_, Nat_) Test1 = λx match x { Nat_/Zero: (Nat_/Zero, Nat_/Zero) Nat_/Succ: (x.x, x.pred) } main = * ================================================ FILE: tests/golden_tests/cli/compile_all.args ================================================ gen-hvm tests/golden_tests/cli/compile_all.bend -Oall ================================================ FILE: tests/golden_tests/cli/compile_all.bend ================================================ type Pair = (Pair fst snd) Pair.get f (Pair/Pair fst snd) = (f fst snd) main = (Pair.get @x @y (+ x y) (Pair/Pair 40 2)) ================================================ FILE: tests/golden_tests/cli/compile_inline.args ================================================ gen-hvm tests/golden_tests/cli/compile_inline.bend -Oinline ================================================ FILE: tests/golden_tests/cli/compile_inline.bend ================================================ (Num) = 42 (Era) = * (RefToRef) = (Era) (Main) = (Era Num RefToRef) ================================================ FILE: tests/golden_tests/cli/compile_no_opts.args ================================================ gen-hvm tests/golden_tests/cli/compile_no_opts.bend -Ono-all -Ono-eta -Ono-prune -Ono-float-combinators -Ono-merge -Ono-inline ================================================ FILE: tests/golden_tests/cli/compile_no_opts.bend ================================================ main = * ================================================ FILE: tests/golden_tests/cli/compile_pre_reduce.args ================================================ gen-hvm tests/golden_tests/cli/compile_pre_reduce.bend -Opre-reduce ================================================ FILE: tests/golden_tests/cli/compile_pre_reduce.bend ================================================ I = (+ 2 3) main = * ================================================ FILE: tests/golden_tests/cli/compile_strict_loop.args ================================================ gen-hvm tests/golden_tests/cli/compile_strict_loop.bend -Ono-all -Arecursion-cycle ================================================ FILE: tests/golden_tests/cli/compile_strict_loop.bend ================================================ A = @a match a { List/Cons: (A a.tail) List/Nil: 0 } main = (A [4 4]) ================================================ FILE: tests/golden_tests/cli/compile_wrong_opt.args ================================================ gen-hvm tests/golden_tests/cli/compile_wrong_opt.bend -Ofoo ================================================ FILE: tests/golden_tests/cli/compile_wrong_opt.bend ================================================ main = * ================================================ FILE: tests/golden_tests/cli/custom_hvm_bin.args ================================================ run tests/golden_tests/cli/custom_hvm_bin.bend --hvm-bin=hvm ================================================ FILE: tests/golden_tests/cli/custom_hvm_bin.bend ================================================ main = @x x ================================================ FILE: tests/golden_tests/cli/debug_list_map.args ================================================ run tests/golden_tests/cli/debug_list_map.bend -d -L -1 ================================================ FILE: tests/golden_tests/cli/debug_list_map.bend ================================================ (Map f []) = [] (Map f (List/Cons head tail)) = (List/Cons (f head) (Map f tail)) (Inc) = @x (+ x 1) (Main) = (Map Inc [1 41 0xFF 90]) ================================================ FILE: tests/golden_tests/cli/debug_u60_to_nat.args ================================================ run tests/golden_tests/cli/debug_u60_to_nat.bend -d 4 ================================================ FILE: tests/golden_tests/cli/debug_u60_to_nat.bend ================================================ type Nat_ = (Z) | (S nat) U60ToNat n = switch n { 0: Nat_/Z _: (Nat_/S (U60ToNat n-1)) } (Main n) = (U60ToNat n) ================================================ FILE: tests/golden_tests/cli/desugar_bool_scott.args ================================================ desugar tests/golden_tests/cli/desugar_bool_scott.bend -Oadt-scott ================================================ FILE: tests/golden_tests/cli/desugar_bool_scott.bend ================================================ type Boolean = True | False main = Boolean/True ================================================ FILE: tests/golden_tests/cli/desugar_float_combinators.args ================================================ desugar tests/golden_tests/cli/desugar_float_combinators.bend -Ofloat-combinators ================================================ FILE: tests/golden_tests/cli/desugar_float_combinators.bend ================================================ Z = @s @z z S = @x @s @z (s (x s z)) get = @Nat (Nat @x (+ x 1) 0) main = (get (S (S Z))) ================================================ FILE: tests/golden_tests/cli/desugar_linearize_matches.args ================================================ desugar tests/golden_tests/cli/desugar_linearize_matches.bend -Olinearize-matches ================================================ FILE: tests/golden_tests/cli/desugar_linearize_matches.bend ================================================ main = λa λb λc switch a { 0: b; _: c } ================================================ FILE: tests/golden_tests/cli/desugar_linearize_matches_alt.args ================================================ desugar tests/golden_tests/cli/desugar_linearize_matches_alt.bend -Olinearize-matches-alt ================================================ FILE: tests/golden_tests/cli/desugar_linearize_matches_alt.bend ================================================ main = λa λb switch a { 0: b; _: b } ================================================ FILE: tests/golden_tests/cli/desugar_merge.args ================================================ desugar tests/golden_tests/cli/desugar_merge.bend -Omerge ================================================ FILE: tests/golden_tests/cli/desugar_merge.bend ================================================ F = @t @f f Z = @s @z z main = (F) ================================================ FILE: tests/golden_tests/cli/desugar_pretty.args ================================================ desugar tests/golden_tests/cli/desugar_pretty.bend -p ================================================ FILE: tests/golden_tests/cli/desugar_pretty.bend ================================================ Foo (a,b) (c,d) = (+ (+ a b) (+ c d)) main = @(x, y) @{a b c} (+ (+ x y) (+ a b)) ================================================ FILE: tests/golden_tests/cli/desugar_prune.args ================================================ desugar tests/golden_tests/cli/desugar_prune.bend -Oprune ================================================ FILE: tests/golden_tests/cli/desugar_prune.bend ================================================ id x = x main = * ================================================ FILE: tests/golden_tests/cli/gen_hvm_no_eta_by_default.args ================================================ gen-hvm tests/golden_tests/cli/gen_hvm_no_eta_by_default.bend ================================================ FILE: tests/golden_tests/cli/gen_hvm_no_eta_by_default.bend ================================================ # Eta-reduction of some recursive functions can mess the performance # of programs targeting the CUDA runtime. # So for now we've disabled it by default when the target architecture # is not C (for which eta-reduction usually seems to not only decrease # the total amount of interactions, but actually slightly increase # performance a little bit is the tested cases). # This test checks that the compiler doesn't eta-reduce when calling # 'gen-hvm', which has an unknown target architecture. # A recursive function make_list n x = switch n { 0: @l l _: @l (l x (make_list n-1 x)) } # A non-recursive function make_10 x = (make_list 10 x) main = (make_10 1) ================================================ FILE: tests/golden_tests/cli/input_file_not_found.args ================================================ run tests/golden_tests/missing_dir/input_file_not_found.bend ================================================ FILE: tests/golden_tests/cli/input_file_not_found.bend ================================================ ================================================ FILE: tests/golden_tests/cli/net_size_too_large.args ================================================ gen-hvm tests/golden_tests/cli/net_size_too_large.bend -Ocheck-net-size ================================================ FILE: tests/golden_tests/cli/net_size_too_large.bend ================================================ type Map_ = Free | Used | (Both a b) type Arr = Null | (Leaf x) | (Node a b) (Swap s a b) = switch s { 0: (Map_/Both a b) _: (Map_/Both b a) } # Sort : Arr -> Arr (Sort t) = (ToArr 0 (ToMap t)) # ToMap : Arr -> Map (ToMap Arr/Null) = Map_/Free (ToMap (Arr/Leaf a)) = (Radix a) (ToMap (Arr/Node a b)) = (Merge (ToMap a) (ToMap b)) # ToArr : U60 -> Map -> Arr (ToArr x Map_/Free) = Arr/Null (ToArr x Map_/Used) = (Arr/Leaf x) (ToArr x (Map_/Both a b)) = let a = (ToArr (+ (* x 2) 0) a) let b = (ToArr (+ (* x 2) 1) b) (Arr/Node a b) # Merge : Map -> Map -> Map (Merge Map_/Free Map_/Free) = Map_/Free (Merge Map_/Free Map_/Used) = Map_/Used (Merge Map_/Used Map_/Free) = Map_/Used (Merge Map_/Used Map_/Used) = Map_/Used (Merge Map_/Free (Map_/Both c d)) = (Map_/Both c d) (Merge (Map_/Both a b) Map_/Free) = (Map_/Both a b) (Merge (Map_/Both a b) (Map_/Both c d)) = (Map_/Both (Merge a c) (Merge b d)) (Merge (Map_/Both a b) Map_/Used) = * (Merge Map_/Used (Map_/Both a b)) = * # Radix : U60 -> Map (Radix n) = let r = Map_/Used let r = (Swap (& n 1) r Map_/Free) let r = (Swap (& n 2) r Map_/Free) let r = (Swap (& n 4) r Map_/Free) let r = (Swap (& n 8) r Map_/Free) let r = (Swap (& n 16) r Map_/Free) let r = (Swap (& n 32) r Map_/Free) let r = (Swap (& n 64) r Map_/Free) let r = (Swap (& n 128) r Map_/Free) let r = (Swap (& n 256) r Map_/Free) let r = (Swap (& n 512) r Map_/Free) let r = (Swap (& n 1024) r Map_/Free) let r = (Swap (& n 2048) r Map_/Free) let r = (Swap (& n 4096) r Map_/Free) let r = (Swap (& n 8192) r Map_/Free) let r = (Swap (& n 16384) r Map_/Free) let r = (Swap (& n 32768) r Map_/Free) let r = (Swap (& n 65536) r Map_/Free) let r = (Swap (& n 131072) r Map_/Free) let r = (Swap (& n 262144) r Map_/Free) let r = (Swap (& n 524288) r Map_/Free) let r = (Swap (& n 1048576) r Map_/Free) let r = (Swap (& n 2097152) r Map_/Free) let r = (Swap (& n 4194304) r Map_/Free) let r = (Swap (& n 8388608) r Map_/Free) r # Reverse : Arr -> Arr (Reverse Arr/Null) = Arr/Null (Reverse (Arr/Leaf a)) = (Arr/Leaf a) (Reverse (Arr/Node a b)) = (Arr/Node (Reverse b) (Reverse a)) # Sum : Arr -> U60 (Sum Arr/Null) = 0 (Sum (Arr/Leaf x)) = x (Sum (Arr/Node a b)) = (+ (Sum a) (Sum b)) # Gen : U60 -> Arr (Gen n) = (Gen.go n 0) (Gen.go n x) = switch n { 0: (Arr/Leaf x) _: let a = (* x 2) let b = (| (* x 2) 1) (Arr/Node (Gen.go n-1 a) (Gen.go n-1 b)) } Main = (Sum (Sort (Reverse (Gen 4)))) ================================================ FILE: tests/golden_tests/cli/no_check_net_size.args ================================================ gen-hvm tests/golden_tests/cli/no_check_net_size.bend -Ono-check-net-size ================================================ FILE: tests/golden_tests/cli/no_check_net_size.bend ================================================ type Map_ = Free | Used | (Both a b) type Arr = Null | (Leaf x) | (Node a b) (Swap s a b) = switch s { 0: (Map_/Both a b) _: (Map_/Both b a) } # Sort : Arr -> Arr (Sort t) = (ToArr 0 (ToMap t)) # ToMap : Arr -> Map (ToMap Arr/Null) = Map_/Free (ToMap (Arr/Leaf a)) = (Radix a) (ToMap (Arr/Node a b)) = (Merge (ToMap a) (ToMap b)) # ToArr : U60 -> Map -> Arr (ToArr x Map_/Free) = Arr/Null (ToArr x Map_/Used) = (Arr/Leaf x) (ToArr x (Map_/Both a b)) = let a = (ToArr (+ (* x 2) 0) a) let b = (ToArr (+ (* x 2) 1) b) (Arr/Node a b) # Merge : Map -> Map -> Map (Merge Map_/Free Map_/Free) = Map_/Free (Merge Map_/Free Map_/Used) = Map_/Used (Merge Map_/Used Map_/Free) = Map_/Used (Merge Map_/Used Map_/Used) = Map_/Used (Merge Map_/Free (Map_/Both c d)) = (Map_/Both c d) (Merge (Map_/Both a b) Map_/Free) = (Map_/Both a b) (Merge (Map_/Both a b) (Map_/Both c d)) = (Map_/Both (Merge a c) (Merge b d)) (Merge (Map_/Both a b) Map_/Used) = * (Merge Map_/Used (Map_/Both a b)) = * # Radix : U60 -> Map (Radix n) = let r = Map_/Used let r = (Swap (& n 1) r Map_/Free) let r = (Swap (& n 2) r Map_/Free) let r = (Swap (& n 4) r Map_/Free) let r = (Swap (& n 8) r Map_/Free) let r = (Swap (& n 16) r Map_/Free) let r = (Swap (& n 32) r Map_/Free) let r = (Swap (& n 64) r Map_/Free) let r = (Swap (& n 128) r Map_/Free) let r = (Swap (& n 256) r Map_/Free) let r = (Swap (& n 512) r Map_/Free) let r = (Swap (& n 1024) r Map_/Free) let r = (Swap (& n 2048) r Map_/Free) let r = (Swap (& n 4096) r Map_/Free) let r = (Swap (& n 8192) r Map_/Free) let r = (Swap (& n 16384) r Map_/Free) let r = (Swap (& n 32768) r Map_/Free) let r = (Swap (& n 65536) r Map_/Free) let r = (Swap (& n 131072) r Map_/Free) let r = (Swap (& n 262144) r Map_/Free) let r = (Swap (& n 524288) r Map_/Free) let r = (Swap (& n 1048576) r Map_/Free) let r = (Swap (& n 2097152) r Map_/Free) let r = (Swap (& n 4194304) r Map_/Free) let r = (Swap (& n 8388608) r Map_/Free) r # Reverse : Arr -> Arr (Reverse Arr/Null) = Arr/Null (Reverse (Arr/Leaf a)) = (Arr/Leaf a) (Reverse (Arr/Node a b)) = (Arr/Node (Reverse b) (Reverse a)) # Sum : Arr -> U60 (Sum Arr/Null) = 0 (Sum (Arr/Leaf x)) = x (Sum (Arr/Node a b)) = (+ (Sum a) (Sum b)) # Gen : U60 -> Arr (Gen n) = (Gen.go n 0) (Gen.go n x) = switch n { 0: (Arr/Leaf x) _: let a = (* x 2) let b = (| (* x 2) 1) (Arr/Node (Gen.go n-1 a) (Gen.go n-1 b)) } Main = (Sum (Sort (Reverse (Gen 4)))) ================================================ FILE: tests/golden_tests/cli/run_add.args ================================================ run tests/golden_tests/cli/run_add.bend 3 6 ================================================ FILE: tests/golden_tests/cli/run_add.bend ================================================ main a b = (+ a b) ================================================ FILE: tests/golden_tests/cli/run_pretty.args ================================================ run tests/golden_tests/cli/run_pretty.bend -p ================================================ FILE: tests/golden_tests/cli/run_pretty.bend ================================================ main a b = switch a { 0: switch b { 0: "ba" _: "ta" } _: "ata" } ================================================ FILE: tests/golden_tests/cli/tuple_readback.args ================================================ run tests/golden_tests/cli/tuple_readback.bend -Ono-float-combinators -Aall ================================================ FILE: tests/golden_tests/cli/tuple_readback.bend ================================================ # We probably will not be able to handle all these main = ( @a (1, a), (1, 2), (*, 2), ($x, @$x *), ((1, @$y $z), (2, @$z $y)), ((@$a $b, @$b $c), (@$c $d, @$d $a)) ) ================================================ FILE: tests/golden_tests/cli/warn_and_err.args ================================================ gen-hvm tests/golden_tests/cli/warn_and_err.bend ================================================ FILE: tests/golden_tests/cli/warn_and_err.bend ================================================ Foo a a = a Main = (Foo a) ================================================ FILE: tests/golden_tests/compile_entrypoint/foo.bend ================================================ bar = λx x foo = (bar 2) ================================================ FILE: tests/golden_tests/compile_file/360_no_scope.bend ================================================ main = let $d = ((@$a $c) 360) let $b = ((@$c $a) $b) let #x{#y($e, $f) #y($g, $h)} = #y(#x{$d $f}, #x{$e, $g}) $h ================================================ FILE: tests/golden_tests/compile_file/add_args.bend ================================================ add x y = (+ x y) main x y = (add x y) ================================================ FILE: tests/golden_tests/compile_file/addition.bend ================================================ main = (λx (+ (+ 1 1) x) 8) ================================================ FILE: tests/golden_tests/compile_file/addition_const.bend ================================================ main = (+ 1 2) ================================================ FILE: tests/golden_tests/compile_file/ask_outside_do.bend ================================================ main = ask x = (Result/Ok x); x ================================================ FILE: tests/golden_tests/compile_file/church_one.bend ================================================ main = (λk λs λz let {s0 s1} = s; (s0 ((k s1) z)) λq λw w) ================================================ FILE: tests/golden_tests/compile_file/church_zero.bend ================================================ main = λs λz z ================================================ FILE: tests/golden_tests/compile_file/complicated_dup.bend ================================================ main = let {x1 x2} = ($a $b); λy let {y1 y2} = y; (λ$a (y1 x1) λ$b (y2 x2)) ================================================ FILE: tests/golden_tests/compile_file/crlf.bend ================================================ a = 1 main = 2 ================================================ FILE: tests/golden_tests/compile_file/cyclic_global_lam.bend ================================================ main = λa ($a λ$a a) ================================================ FILE: tests/golden_tests/compile_file/def_pat_unscoped.bend ================================================ add $a b = (+ $a b) main = (add 9 4) ================================================ FILE: tests/golden_tests/compile_file/dup_apply.bend ================================================ main = λa let {a1 a2} = a; (a1 a2) ================================================ FILE: tests/golden_tests/compile_file/dup_global_lam.bend ================================================ main = let {x1 x2} = $a; ((λ$a λb b) (x1 x2)) ================================================ FILE: tests/golden_tests/compile_file/elif.bend ================================================ def main: cond1 = 1 == 2 cond2 = 2 < 1 cond3 = 3 > 2 cond4 = 2 == 2 if cond1: res = 1 elif cond2: res = 2 elif cond3: res = 3 elif cond4: res = 4 else: res = 0 return res ================================================ FILE: tests/golden_tests/compile_file/elif_fun.bend ================================================ main = let cond1 = (== 1 2) let cond2 = (< 2 1) let cond3 = (> 3 2) let cond4 = (== 2 2) if cond1 { 1 } elif cond2 { 2 } elif cond3 { 3 } elif cond4 { 4 } else { 0 } ================================================ FILE: tests/golden_tests/compile_file/elif_no_else.bend ================================================ def main: if 1 == 1: return 0 elif 2 == 2: return 1 ================================================ FILE: tests/golden_tests/compile_file/erased_dup.bend ================================================ main = λa let {a1 a2} = a; a2 ================================================ FILE: tests/golden_tests/compile_file/error_data_def_name.bend ================================================ type A = A A/A = 0 main = A/A ================================================ FILE: tests/golden_tests/compile_file/error_messages.bend ================================================ data A = (A) data B = (B) data C = (B) Foo (C) = * Foo (D) = * Foo2 (E) = * Main = * ================================================ FILE: tests/golden_tests/compile_file/f24_oper.bend ================================================ main = (/ (* +124.0928 1.24) (+ 0.0 -235.12235)) ================================================ FILE: tests/golden_tests/compile_file/fst_snd.bend ================================================ main = let fst = (@t let (f, *) = t; f); let snd = (@t let (*, s) = t; s); (snd (fst ((1, 3), 2))) ================================================ FILE: tests/golden_tests/compile_file/global_lam.bend ================================================ main = ((λ$a λa a) $a) ================================================ FILE: tests/golden_tests/compile_file/i24_oper.bend ================================================ main = (* (+ +1 -1) (- -12 +14)) ================================================ FILE: tests/golden_tests/compile_file/id.bend ================================================ main = λa a ================================================ FILE: tests/golden_tests/compile_file/infer_dup.bend ================================================ main = λa (a a) ================================================ FILE: tests/golden_tests/compile_file/inlining.bend ================================================ (Num) = 42 (Era) = * (RefToRef) = (Era) (Main) = (Era Num RefToRef) ================================================ FILE: tests/golden_tests/compile_file/just_a_name.bend ================================================ asdf ================================================ FILE: tests/golden_tests/compile_file/just_data.bend ================================================ type ================================================ FILE: tests/golden_tests/compile_file/just_paren.bend ================================================ main = * ( ================================================ FILE: tests/golden_tests/compile_file/just_rule_paren.bend ================================================ (rule) ================================================ FILE: tests/golden_tests/compile_file/let_substitution.bend ================================================ main = let x = λa (a a); x ================================================ FILE: tests/golden_tests/compile_file/let_tup.bend ================================================ main = let tup = (@x@y x, @x@y y); tup ================================================ FILE: tests/golden_tests/compile_file/lets.bend ================================================ main = let a0 = λx0 x0; let a1 = λx1 x1; let a2 = λx2 x2; let a3 = λx3 x3; let a4 = λx4 x4; (a1 (a2 a2) (a3 a3 a3) (a4 a4 a4 a4)) ================================================ FILE: tests/golden_tests/compile_file/long_name.bend ================================================ (WowThis_is_a_very_long_name_no_way_ItFits) = λa a main = λa (WowThis_is_a_very_long_name_no_way_ItFits *) ================================================ FILE: tests/golden_tests/compile_file/match.bend ================================================ main = switch x = (+ 0 1) { 0: λt λf t _: λt λf f } ================================================ FILE: tests/golden_tests/compile_file/mismatched_ask_statements.bend ================================================ type Bool: T F def main: with IO: match _ = Bool/T: case Bool/T: x <- wrap(0) case Bool/F: x = wrap(0) return wrap(x) ================================================ FILE: tests/golden_tests/compile_file/missing_adt_eq.bend ================================================ type Adt ================================================ FILE: tests/golden_tests/compile_file/missing_ctrs.bend ================================================ type Adt = ================================================ FILE: tests/golden_tests/compile_file/missing_pat.bend ================================================ main = @x match x { : * } ================================================ FILE: tests/golden_tests/compile_file/names_starting_with_keywords.bend ================================================ A = @matchn matchn B = @usen usen C = @letn letn D = @don don E = @switchn switchn main = * ================================================ FILE: tests/golden_tests/compile_file/nested_ctr_wrong_arity.bend ================================================ type Pair = (Pair fst snd) fst_fst (Pair/Pair (Pair/Pair fst) *) = fst main = (fst_fst (Pair/Pair (Pair/Pair 1 2) 3)) ================================================ FILE: tests/golden_tests/compile_file/nested_let.bend ================================================ main = let (a, b) = ((2, 4), (3, 6)); let (a1, a2) = a; let (b1, b2) = b; b1 ================================================ FILE: tests/golden_tests/compile_file/number_too_large.bend ================================================ main = 0x10000000 ================================================ FILE: tests/golden_tests/compile_file/nums.bend ================================================ main = (+ 0xFF_FFFF (+ 0b101 1_000)) ================================================ FILE: tests/golden_tests/compile_file/op2.bend ================================================ main = (% (+ (- (* (/ (< (> (| (& (== (!= 0 1) 2) 3) 4) 5) 6) 7) 8) 9) 10) 11) ================================================ FILE: tests/golden_tests/compile_file/redex_order.bend ================================================ # We want the nested calls in foo to be compiled as redexes written in outer to inner order # So they should compile to: @foo = root_tree & a ~ ... & b ~ ... & c ~ ... foo = @x (a (b (c x))) foo2 = (a (b (c 0))) a = @x x b = @x x c = @x x main = (foo foo2) ================================================ FILE: tests/golden_tests/compile_file/redex_order_recursive.bend ================================================ tail_recursive = @x (x @pred @acc (tail_recursive pred (+ 1 acc)) @acc 0) fold_ = @bm (bm @lft @rgt (add (fold_ lft) (fold_ rgt)) @s @z (s @s @z z) ) add = @a (a @p @b (add p @s @z (s b)) @b b ) List.sum xs acc = match xs { List/Nil: acc List/Cons: (List.sum xs.tail (+ xs.head acc)) } List.len xs = match xs { List/Nil: 0 List/Cons: (+ 1 (List.len xs.tail)) } List.len_tr xs acc = match xs { List/Nil: acc List/Cons: (List.len_tr xs.tail (+ 1 acc)) } List.map xs f = match xs { List/Nil: List/Nil List/Cons: (List/Cons (f xs.head) (List.map xs.tail f)) } List.concat xs ys = match xs { List/Nil: ys List/Cons: (List/Cons xs.head (List.concat xs.tail ys)) } List.reverse_bad xs = match xs { List/Nil: List/Nil List/Cons: (List.concat (List.reverse_bad xs.tail) (List/Cons xs.head List/Nil)) } List.reverse_tr xs acc = (List.reverse_over xs List/Nil) List.fold xs c n = match xs { List/Nil: n List/Cons: (c xs.head (List.fold xs.tail c n)) } List.reduce xs f acc = match xs { List/Nil: acc List/Cons: (List.reduce xs.tail f (f acc xs.head)) } List.reverse_over xs ys = match xs { List/Nil: ys List/Cons: (List.reverse_over xs.tail (List/Cons xs.head ys)) } Tree.leaves tree = match tree { Tree/Leaf: 1 Tree/Node: (+ (Tree.leaves tree.left) (Tree.leaves tree.right)) } Tree.nodes tree = match tree { Tree/Leaf: 0 Tree/Node: (+ 1 (+ (Tree.nodes tree.left) (Tree.nodes tree.right))) } Tree.height tree = match tree { Tree/Leaf: 0 Tree/Node: (+ 1 (max (Tree.height tree.left) (Tree.height tree.right))) } Tree.map tree f = match tree { Tree/Leaf: (Tree/Leaf (f tree.value)) Tree/Node: (Tree/Node (Tree.map tree.left f) (Tree.map tree.right f)) } max a b = switch (> a b) { 0: b _: a } Tree.flip tree = match tree { Tree/Leaf: tree Tree/Node: (Tree/Node (Tree.flip tree.right) (Tree.flip tree.left)) } calc = let n0 = 1 let n1 = (* n0 n0) let n2 = (* n1 n1) let n3 = (* n2 n2) let n4 = (* n3 n3) let n5 = (* n4 n4) (Foo (+ n0 n1) (+ n2 n3) (+ n4 n5)) Foo = @a @b @c @x (x a b c) main = * ================================================ FILE: tests/golden_tests/compile_file/ref_to_main.bend ================================================ Foo = main main = Foo ================================================ FILE: tests/golden_tests/compile_file/ref_to_ref.bend ================================================ A1 = A2 A2 = 1 B1 = B2 B2 = B3 B3 = B4 B4 = B5 B5 = 2 C1 = B4 main = ((A1, B1), C1) ================================================ FILE: tests/golden_tests/compile_file/repeated_bind_rule.bend ================================================ Foo a a = a main = (Foo 1 2) ================================================ FILE: tests/golden_tests/compile_file/simple_tup.bend ================================================ main = (0, 42) ================================================ FILE: tests/golden_tests/compile_file/switch_all_patterns.bend ================================================ zero_succ = @x switch x { 0: 0 _: x-1 } succ_zero = @x switch x { _: x-1 0: 0 } zero = @x switch x { 0: 0 } succ = @x switch x { _: x-1 } succ_zero_succ = @x switch x { _: x-1 0: 0 _: (+ x-1 1) } zero_succ_zero = @x switch x { 0: 0 _: x-1 0: 1 } zero_zero_succ = @x switch x { 0: 0 0: 1 _: x-1 } zero_succ_succ = @x switch x { 0: 0 _: x-1 _: (+ x-1 1) } main = 0 ================================================ FILE: tests/golden_tests/compile_file/switch_in_switch_arg.bend ================================================ main x = switch x = (switch x {0: 0; _: x-1}) { 0: 0 _: x } ================================================ FILE: tests/golden_tests/compile_file/switch_incomplete.bend ================================================ # This should be interpreted as a switch with a SUP argument that is missing its elements. main = switch {} ================================================ FILE: tests/golden_tests/compile_file/switch_unscoped_lambda.bend ================================================ lambda_out = @x @$y switch x { 0: $y _: x-1 } lambda_in = @x (switch x { 0: @x x _: @$y x-1 } $y) main = * ================================================ FILE: tests/golden_tests/compile_file/top_level_name_slashslash.bend ================================================ def random//constant(): return 3.14 def //thisshouldfail(): return random//constant() def main: return //thisshouldfail() ================================================ FILE: tests/golden_tests/compile_file/tup.bend ================================================ main = let x = ((1, 4), (2, 3)); x ================================================ FILE: tests/golden_tests/compile_file/tup_add.bend ================================================ main = let (a, b) = (1, 2); (+ a b) ================================================ FILE: tests/golden_tests/compile_file/unbound_unscoped_var.bend ================================================ main = @a $a ================================================ FILE: tests/golden_tests/compile_file/unbound_var.bend ================================================ main = a ================================================ FILE: tests/golden_tests/compile_file/unbound_var_scope.bend ================================================ # Fully parenthesized, this is (λa ((λb b) b)). # Since applications must have (), the second 'b' is not in scope main = λa (λb b b) ================================================ FILE: tests/golden_tests/compile_file/unbound_with_tup_pattern.bend ================================================ (Foo (*, *)) = a main = * ================================================ FILE: tests/golden_tests/compile_file/underscore.bend ================================================ const _ = 2 main = (const 0) ================================================ FILE: tests/golden_tests/compile_file/unexpected_top_char.bend ================================================ * ================================================ FILE: tests/golden_tests/compile_file/unscoped_dup_use.bend ================================================ main = @$a ($a $a) ================================================ FILE: tests/golden_tests/compile_file/unscoped_supercombinator.bend ================================================ Foo = @f (f @a @$b ($b a) @a @b (b a)) main = (Foo *) ================================================ FILE: tests/golden_tests/compile_file/unused_let.bend ================================================ # theoretically, this let could be elided and no dups would need to be emitted # but this isn't legal in all cases, and it's unclear what heuristics could work here main = @x let * = (+ x x); x ================================================ FILE: tests/golden_tests/compile_file/unused_unscoped_bind.bend ================================================ main = λ$a * ================================================ FILE: tests/golden_tests/compile_file/variable_name_double_underscore.bend ================================================ def main: return __this_should_fail__(*) ================================================ FILE: tests/golden_tests/compile_file/vicious_circles.bend ================================================ dup_self = let {$x $y} = $x; $y disconnected_self_lam = let $x = @* $x; * main = (dup_self, disconnected_self_lam) ================================================ FILE: tests/golden_tests/compile_file/warn_and_err.bend ================================================ Foo a a = a Main = (Foo a) ================================================ FILE: tests/golden_tests/compile_file/with_clause_parse_err.bend ================================================ main = @a @b switch b witha{ 0: 1 _: 0 } ================================================ FILE: tests/golden_tests/compile_file/wrong_ctr_arity.bend ================================================ type Boxed = (Box val) Bar (*, (Boxed/Box x y)) = x main = * ================================================ FILE: tests/golden_tests/compile_file/wrong_ctr_var_arity.bend ================================================ type Tup = (pair a b) (foo Tup/pair) = pair main = * ================================================ FILE: tests/golden_tests/compile_file/wrong_nums.bend ================================================ main = (+ 0b012345 0FA) ================================================ FILE: tests/golden_tests/compile_file/wrong_unicode_escape.bend ================================================ main = (String.cons '\u{1' "\u2}\u{zxcx}") ================================================ FILE: tests/golden_tests/compile_file_o_all/addition.bend ================================================ main = (λx (+ (+ 1 1) x) 8) ================================================ FILE: tests/golden_tests/compile_file_o_all/addition_var_fst.bend ================================================ main = λx (+ x 1) ================================================ FILE: tests/golden_tests/compile_file_o_all/adt_option_and.bend ================================================ type Option = (Some val) | None Option/and = @a @b match a { Option/Some: match b { Option/Some: (Option/Some (a.val, b.val)) Option/None: Option/None } Option/None: Option/None } main = (Option/and (Option/Some 1) (Option/Some 3)) ================================================ FILE: tests/golden_tests/compile_file_o_all/adt_string.bend ================================================ type String = S main = String/S ================================================ FILE: tests/golden_tests/compile_file_o_all/and.bend ================================================ type bool = true | false and a bool/false = bool/false and a bool/true = a main = (and bool/true bool/false) ================================================ FILE: tests/golden_tests/compile_file_o_all/bad_parens_making_erased_let.bend ================================================ X = λx x (main) = ( let two = (λf1λx1 (f1 λf2λx2 (f2 λf0λx0 x0))); let qua = (λs1λz1 (s1 λs2λz2 (s2 λs3λz3 (s3 λs4λz4 (s4 λs0λz0 z0))))); X X (X two qua) # Because there is no parens around the return term, the lets are only in scope for the first X # This test is to make sure that the affine checking and duping infering marks them as erased as we expect. # We expect an unbound variable error on two and qua. ) ================================================ FILE: tests/golden_tests/compile_file_o_all/bool.bend ================================================ (true) = λt λf t (fals) = λt λf f (Not) = λx (x fals true) (main) = (Not true) ================================================ FILE: tests/golden_tests/compile_file_o_all/cyclic_dup.bend ================================================ main = let {x1 x2} = y1; let {y1 y2} = x1; (x2 y2) ================================================ FILE: tests/golden_tests/compile_file_o_all/double_main.bend ================================================ Main = λa a main = λb b ================================================ FILE: tests/golden_tests/compile_file_o_all/eta_chain.bend ================================================ Baz a b c = (+ a (+ b c)) Bar a b = (Baz a b) Foo a = (Bar a) main = λa (Foo a) ================================================ FILE: tests/golden_tests/compile_file_o_all/ex0.bend ================================================ C_z = λs λz z C_s = λk λs let {s0 s1} = s; λz (s0 (k s1 z)) Z = λs λz z S = λk λs λz (s k) C_1 = λs λz (s z) C_2 = λs let {s0 s1} = s; λz (s0 (s1 z)) main = (C_2 S Z) ================================================ FILE: tests/golden_tests/compile_file_o_all/ex2.bend ================================================ (c2) = λs let {s0 s1} = s; λz (s0 (s1 z)) (O) = λt λo λi λe (o t) (I) = λt λo λi λe (i t) (E) = λo λi λe e (run) = λx (x runO runI E) (runO) = λx (run (dec (O x))) (runI) = λx (run (dec (I x))) (dec) = λx (x decO decI E) (decO) = λx (I (dec x)) (decI) = λx (low x) (low) = λx (x lowO lowI E) (lowO) = λx (O (O x)) (lowI) = λx (O (I x)) (main) = (run (c2 I E)) ================================================ FILE: tests/golden_tests/compile_file_o_all/example.bend ================================================ # Write definitions like this (Def1) = (λa a λb b) # You can call a definition by just referencing its name # It will be substituted in place of the reference (Def2) = (λa a Def1) # Definitions and variables can have names in upper and lower case and contain numbers # Names defined in a more inner position shadow names in an outer position (def3) = (λDef1 Def1 λx λx x) # The language is affine, but if you use a variable more than once the compiler inserts duplications for you # Of course you can always do them manually (def4) = λz let {z1 z2} = z; (z1 (λx (x x x x x) z2)) # You can use machine numbers and some native numeric operations # Numeric operations can only reduce numbers, doing (+ (λx x) 1) will not do anything (nums) = λx1 λx2 (* (+ x1 1) (/ (- x2 2) 1)) # All files must have a main definition to be run. # You can execute a program in HVM with "cargo run -- --run " # Other options are "--check" (the default mode) to just see if the file is well formed # and "--compile" to output hvm-core code. # (main) = (Def2 1) (main) = (Def2 1) ================================================ FILE: tests/golden_tests/compile_file_o_all/exp.bend ================================================ # currently broken without lazy_mode main = ((λfλx (f (f x))) (λfλx (f (f x)))) ================================================ FILE: tests/golden_tests/compile_file_o_all/expr.bend ================================================ type Expr = (Var name) | (Num val) | (App fun arg) | (Fun name body) | (If cond then else) | (Let bind val next) | (Dup fst snd val next) | (Tup fst snd) | (Op2 op fst snd) type Op = Add | Sub | Mul | Div main = (Expr/Let (Expr/Var 0) (Expr/Op2 Op/Mul (Expr/Op2 Op/Sub (Expr/Num 2) (Expr/Num 1) (Expr/Num 3))) (Expr/Dup (Expr/Var 1) (Expr/Var 2) (Expr/Var 0) (Expr/App (Expr/Var 1) (Expr/Var 2))) ) ================================================ FILE: tests/golden_tests/compile_file_o_all/extracted_match_pred.bend ================================================ # We expect the inferred 'λn-1' from the match to be extracted which allows this recursive func val = λn (switch n { 0: valZ; _: (valS n-1) }) valZ = 0 valS = λp (val p) main = (val 1) ================================================ FILE: tests/golden_tests/compile_file_o_all/fst.bend ================================================ Fst (f, s) = f Main = (Fst (4, 8)) ================================================ FILE: tests/golden_tests/compile_file_o_all/fst_fst.bend ================================================ FstFst (f1, s1) (f2, s2) = (f1, f2) Main = (FstFst (3, 9) (4, 12)) ================================================ FILE: tests/golden_tests/compile_file_o_all/hvm1_main.bend ================================================ Main = λa a ================================================ FILE: tests/golden_tests/compile_file_o_all/inline_app.bend ================================================ Rul1 = λx x Rul2 = λx x Rul3 = (Rul1 Rul2) main = (Rul3 Rul3) ================================================ FILE: tests/golden_tests/compile_file_o_all/inlining.bend ================================================ (Num) = 42 (Era) = * (RefToRef) = (Era) (Main) = (Era Num RefToRef) ================================================ FILE: tests/golden_tests/compile_file_o_all/linearize_match.bend ================================================ main = @a @b switch a { 0: b; _: (+ a-1 b); } ================================================ FILE: tests/golden_tests/compile_file_o_all/list_merge_sort.bend ================================================ type Bool = True | False type List_ = (Cons head tail) | Nil If Bool/True then else = then If Bool/False then else = else Pure x = (List_/Cons x List_/Nil) Map List_/Nil f = List_/Nil Map (List_/Cons h t) f = (List_/Cons (f h) (Map t f)) MergeSort cmp xs = (Unpack cmp (Map xs Pure)) Unpack cmp List_/Nil = List_/Nil Unpack cmp (List_/Cons h List_/Nil) = h Unpack cmp xs = (Unpack cmp (MergePair cmp xs)) MergePair cmp (List_/Cons h1 (List_/Cons h2 t)) = (List_/Cons (Merge cmp h1 h2) (MergePair cmp t)) MergePair cmp xs = xs Merge cmp List_/Nil ys = ys Merge cmp xs List_/Nil = xs Merge cmp (List_/Cons xh xt) (List_/Cons yh yt) = (If (cmp xh yh) let ys = (List_/Cons yh yt) (List_/Cons xh (Merge cmp xt ys)) let xs = (List_/Cons xh xt) (List_/Cons yh (Merge cmp xs yt)) ) main = MergeSort ================================================ FILE: tests/golden_tests/compile_file_o_all/list_reverse.bend ================================================ type list = (cons h t) | nil reverse (list/cons h t) = (concat (reverse t) (list/cons h list/nil)) reverse list/nil = list/nil concat (list/cons h t) x = (list/cons h (concat t x)) concat list/nil x = x main = (reverse (list/cons 3 (list/cons 2 (list/cons 1 list/nil)))) ================================================ FILE: tests/golden_tests/compile_file_o_all/match_adt_non_exhaustive.bend ================================================ type Maybe_ = (Some val) | None main = @maybe match maybe { Maybe_/None: 0 Maybe_/Some: match maybe.val { Maybe_/None: 0 } } ================================================ FILE: tests/golden_tests/compile_file_o_all/match_dup_and_reconstruction.bend ================================================ type Box = (Boxed val) Got = @a match a { Box/Boxed: (a, a.val) } main = (Got (Box/Boxed 10)) ================================================ FILE: tests/golden_tests/compile_file_o_all/match_mult_linearization.bend ================================================ main = @a @b @c @d switch a { 0: (+ (+ b c) d); _: (+ (+ (+ a-1 b) c) d); } ================================================ FILE: tests/golden_tests/compile_file_o_all/match_num_explicit_bind.bend ================================================ pred = @n switch n { 0: 0 _: n-1 } main = (pred 4) ================================================ FILE: tests/golden_tests/compile_file_o_all/match_tup.bend ================================================ Sum (a, b) = (+ a b) Main = (Sum (7, 3)) ================================================ FILE: tests/golden_tests/compile_file_o_all/merge_definitions.bend ================================================ true = @t @f t false = @t @f f fst = @a @b a snd = @a @b b main = @* (fst true (snd false *)) ================================================ FILE: tests/golden_tests/compile_file_o_all/non_exhaustive_and.bend ================================================ type Bool = T | F Bool.and Bool/T Bool/T = Bool/T Bool.and Bool/F Bool/F = Bool/F Main = * ================================================ FILE: tests/golden_tests/compile_file_o_all/non_exhaustive_different_types.bend ================================================ # There was a bug where it would say "Non-exhaustive pattern (foo f1 f2 f3 f3)", # repeating the missing constructor for the next args. type b1 = f1 | t1 type b2 = f2 | t2 type b3 = f3 | t3 type b4 = f4 | t4 (foo b1/f1 b2/f2 b3/f3 b4/f4) = 0 (foo b1/f1 b2/f2 b3/f3 b4/t4) = 1 (main) = (foo b1/f1 b2/f2 b3/f3 b4/f4) ================================================ FILE: tests/golden_tests/compile_file_o_all/non_exhaustive_pattern.bend ================================================ type Type = A | B | C | D Foo Type/A Type/B Type/C Type/D = 0 Foo Type/A Type/B Type/D Type/D = 1 Foo a b Type/D Type/D = 2 main = (Foo Type/A Type/B Type/C Type/D) ================================================ FILE: tests/golden_tests/compile_file_o_all/non_exhaustive_tree.bend ================================================ (Warp s (Tree/Leaf a) (Tree/Leaf b)) = 0 (Warp s (Tree/Node a b) (Tree/Node c d)) = 1 main = * ================================================ FILE: tests/golden_tests/compile_file_o_all/num_pattern_with_var.bend ================================================ # We had a bug where this gave the incorrect error: "Expected a number but found 'a' at definition 'Foo'." type bool = false | true (Foo bool/false a) = 0 (Foo bool/true 0) = 0 (Foo bool/true n) = n Main = (Foo bool/true 3) ================================================ FILE: tests/golden_tests/compile_file_o_all/recursive_combinator_inactive.bend ================================================ # `Foo` inside the term `{Foo Foo}` is not in a active position, tests that it is not unnecessarily extracted Foo = @a switch a { 0: {Foo Foo}; _: @* a-1 } main = (Foo 0) ================================================ FILE: tests/golden_tests/compile_file_o_all/repeated_name_trucation.bend ================================================ long_name_that_truncates = @a @b long_name_that_truncates long_name_that_truncates_too = @a a main = (long_name_that_truncates long_name_that_truncates_too) ================================================ FILE: tests/golden_tests/compile_file_o_all/scrutinee_reconstruction.bend ================================================ type Option = (Some val) | None Option/or = @a @b match a { Option/Some: a Option/None: b } main = (Option/or (Option/Some 5) (Option/None)) ================================================ FILE: tests/golden_tests/compile_file_o_all/self_ref.bend ================================================ Foo = Foo main = Foo ================================================ FILE: tests/golden_tests/compile_file_o_all/snd.bend ================================================ snd = @t let (*, s) = t; s main = let x = (0, 42); (snd x) ================================================ FILE: tests/golden_tests/compile_file_o_all/spacing.bend ================================================ (main) = λa (λa a a a) ================================================ FILE: tests/golden_tests/compile_file_o_all/spacing2.bend ================================================ main = (λa a λa a) ================================================ FILE: tests/golden_tests/compile_file_o_all/str.bend ================================================ main = "main =" ================================================ FILE: tests/golden_tests/compile_file_o_all/sum_predicates.bend ================================================ sum_pred = @a @b switch a { 0: switch b { 0: 0 _: b-1 }; _: switch b { 0: a-1 _: (+ a-1 b-1) } } main = (sum_pred 8 5) ================================================ FILE: tests/golden_tests/compile_file_o_all/tagged_dup.bend ================================================ main = let #i {a b} = @x x; let #i {c d} = @x x; let #i {e f} = @x x; (a b c d e f) ================================================ FILE: tests/golden_tests/compile_file_o_all/tagged_lam.bend ================================================ main = #foo ((#foo @x (+ x 1), #foo @x (* x x)) 2) ================================================ FILE: tests/golden_tests/compile_file_o_all/tagged_sup.bend ================================================ a = #i {λx x λx x} b = #i {λx x λx x} c = #j {λx x λx x} main = (a b c) ================================================ FILE: tests/golden_tests/compile_file_o_all/unapplied_eta.bend ================================================ Id = λa a main = λa (Id a) ================================================ FILE: tests/golden_tests/compile_file_o_all/unscoped_eta.bend ================================================ main = @a @$b (a $b) ================================================ FILE: tests/golden_tests/compile_file_o_all/var_shadows_ref.bend ================================================ (a) = λx x (main) = (a (λa a)) ================================================ FILE: tests/golden_tests/compile_file_o_all/weekday.bend ================================================ type Weekday = Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday main = (@x x Weekday/Saturday) ================================================ FILE: tests/golden_tests/compile_file_o_no_all/bitonic_sort.bend ================================================ type Error = Err # Atomic Swapper (Swap n a b) = switch n { 0: (Tree/Node a b) _: (Tree/Node b a) } # Swaps distant values in parallel; corresponds to a Red Box (Warp s (Tree/Leaf a) (Tree/Leaf b)) = (Swap (^ (> a b) s) (Tree/Leaf a) (Tree/Leaf b)) (Warp s (Tree/Node a b) (Tree/Node c d)) = (Join (Warp s a c) (Warp s b d)) (Warp s a b) = Error/Err # Rebuilds the warped tree in the original order (Join (Tree/Node a b) (Tree/Node c d)) = (Tree/Node (Tree/Node a c) (Tree/Node b d)) (Join a b) = Error/Err # Recursively warps each sub-tree; corresponds to a Blue/Green Box (Flow s (Tree/Leaf a)) = (Tree/Leaf a) (Flow s (Tree/Node a b)) = (Down s (Warp s a b)) # Propagates Flow downwards (Down s (Tree/Leaf a)) = (Tree/Leaf a) (Down s (Tree/Node a b)) = (Tree/Node (Flow s a) (Flow s b)) # Bitonic Sort (Sort s (Tree/Leaf a)) = (Tree/Leaf a) (Sort s (Tree/Node a b)) = (Flow s (Tree/Node (Sort 0 a) (Sort 1 b))) # Generates a tree of depth `n` (Gen n x) = switch n { 0: (Tree/Leaf x) _: (Tree/Node (Gen n-1 (* x 2)) (Gen n-1 (+ (* x 2) 1))) } # Reverses a tree (Rev (Tree/Leaf x)) = (Tree/Leaf x) (Rev (Tree/Node a b)) = (Tree/Node (Rev b) (Rev a)) # Sums a tree (Sum (Tree/Leaf x)) = x (Sum (Tree/Node a b)) = (+ (Sum a) (Sum b)) Main = (Sum (Sort 0 (Rev (Gen 4 0)))) ================================================ FILE: tests/golden_tests/compile_file_o_no_all/list_reverse.bend ================================================ type list = (cons h t) | nil reverse (list/cons h t) = (concat (reverse t) (list/cons h list/nil)) reverse list/nil = list/nil concat (list/cons h t) x = (list/cons h (concat t x)) concat list/nil x = x main = (reverse (list/cons 3 (list/cons 2 (list/cons 1 list/nil)))) ================================================ FILE: tests/golden_tests/compile_file_o_no_all/redex_order.bend ================================================ # We want the nested calls in foo to be compiled as redexes written in outer to inner order # So they should compile to: @foo = root_tree & a ~ ... & b ~ ... & c ~ ... foo = @x (a (b (c x))) foo2 = (a (b (c 0))) bar = (a (b (c 0) (c (d 1))) (b (c (d 2)) (c 3))) #bar = ( # ( # a # ( # (b (c 0)) # (c (d 1)) # ) # ) # ( # ( # b # (c (d 2)) # ) # (c 3) # ) #) a = @x x b = @x x c = @x x d = @x x main = (foo foo2) ================================================ FILE: tests/golden_tests/compile_file_o_no_all/sum_tree.bend ================================================ add = λa λb (+ a b) gen = λn switch n { 0: (Tree/Leaf 1) _: (Tree/Node (gen n-1) (gen n-1)) } sum = λt match t { Tree/Leaf: t.value Tree/Node: (add (sum t.left) (sum t.right)) } main = (sum (gen 8)) ================================================ FILE: tests/golden_tests/compile_long/huge_tree.bend ================================================ type Tree_ = (Node lt rt rd ld) | (Leaf val) main = (Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (1)) (Tree_/Leaf (1)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (1)) (Tree_/Leaf (1)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (1)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (1)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (1)) (Tree_/Leaf (1)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (1)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (1)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (1)) (Tree_/Leaf (1)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (1)) (Tree_/Leaf (1)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (1)) (Tree_/Leaf (1)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (1)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (1)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (1)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (1)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (1)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (1)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (16)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (28)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (23)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (10)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (14)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (15)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (16)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (28)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (81)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (10)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (14)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (5)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (7)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (9)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (11)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (22)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (17)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (57)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (29)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (5)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (9)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (11)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (22)) (Tree_/Leaf (0)))))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (23)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (81)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (15)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (57)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (7)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (29)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) ((Tree_/Node (Tree_/Leaf (0)) ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (17)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)))))) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node (Tree_/Leaf (55)) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) ((Tree_/Node ((Tree_/Node ((Tree_/Node (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (55)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)))) (Tree_/Leaf (0)) (Tree_/Leaf (0)) (Tree_/Leaf (0))) ================================================ FILE: tests/golden_tests/compile_long/long_str_file.bend ================================================ main = "(Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (1)) (Leaf (1)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (1)) (Leaf (1)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)))) ((Node ((Node (Leaf (1)) (Leaf (0)) (Leaf (0)) (Leaf (1)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (1)) (Leaf (1)))) (Leaf (0)) (Leaf (0)))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (1)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (1)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (1)) (Leaf (1)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (1)) (Leaf (1)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (1)) (Leaf (1)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (1)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (1)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (1)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (1)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (1)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (1)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))))))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)))))) ((Node ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))) ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))))) ((Node (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))))) ((Node ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))))))))) ((Node ((Node ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))))) (Leaf (0)) ((Node ((Node ((Node ((Node ((Node (Leaf (16)) (Leaf (0)) (Leaf (0)) (Leaf (15)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (28)) (Leaf (0)) (Leaf (0)) (Leaf (23)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (10)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (14)) (Leaf (0)) (Leaf (0)) (Leaf (15)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (16)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (28)) (Leaf (0)))))) ((Node ((Node (Leaf (81)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (10)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (14)) (Leaf (0)))))))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (0)) (Leaf (5)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (0)) (Leaf (0)) (Leaf (7)) (Leaf (0)))))) ((Node ((Node (Leaf (9)) (Leaf (0)) (Leaf (0)) (Leaf (11)))) (Leaf (0)) (Leaf (0)) ((Node (Leaf (22)) (Leaf (0)) (Leaf (0)) (Leaf (17)))))) ((Node ((Node (Leaf (57)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (29)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (5)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (9)) (Leaf (0)))) (Leaf (0)) ((Node (Leaf (0)) (Leaf (11)) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (0)) (Leaf (22)) (Leaf (0)))))))) ((Node ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (23)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)))) ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (81)) (Leaf (0)))) ((Node (Leaf (0)) (Leaf (15)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)))) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (57)) (Leaf (0)))) ((Node (Leaf (7)) (Leaf (0)) (Leaf (0)) (Leaf (29)))) (Leaf (0)) (Leaf (0)))) ((Node (Leaf (0)) ((Node (Leaf (0)) (Leaf (17)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)))))) ((Node ((Node (Leaf (0)) (Leaf (0)) ((Node ((Node (Leaf (55)) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) ((Node ((Node ((Node (Leaf (0)) (Leaf (0)) (Leaf (55)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)))) (Leaf (0)) (Leaf (0)) (Leaf (0)))" ================================================ FILE: tests/golden_tests/desugar_file/ask_branch.bend ================================================ type Bool: T F def main: with IO: match _ = Bool/T: case Bool/T: x <- wrap(0) case Bool/F: x <- wrap(0) return wrap(x) ================================================ FILE: tests/golden_tests/desugar_file/bind_syntax.bend ================================================ Result/bind (Result/Ok val) f = ((undefer f) val) Result/bind err _ = err safe_div a b = switch b { 0: (Result/Err "Div by 0") _: (Result/Ok (/ a b)) } safe_rem a b = switch b { 0: (Result/Err "Mod by 0") _: (Result/Ok (% a b)) } Main = with Result { ask y = (safe_div 3 2) ask x = (safe_rem y 0); x } ================================================ FILE: tests/golden_tests/desugar_file/combinators.bend ================================================ (foo) = λa λb λc (foo a) (bar) = λa λb (a bar b) (List/ignore list ignore) = match list { List/Cons: (List/ignore list.tail (List/ignore)) List/Nil: 0 } (baz) = {0 1 2 3 λa a foo} (qux) = {0 qux} (clax) = (λx x λa λb λc λd (clax d)) (tup) = (tup, 1, 0) (list) = [0 list] (A x) = (let {a b} = A; λc (a b c) x) (B x) = (let (a, b) = B; λc (a b c) x) (Main) = list ================================================ FILE: tests/golden_tests/desugar_file/deref_loop.bend ================================================ type nat = (succ pred) | zero foo = @x match x { nat/succ: x.pred nat/zero: (bar 0) } bar = (foo 1) main = (foo 0) ================================================ FILE: tests/golden_tests/desugar_file/dup_linearization.bend ================================================ main = let a = * let b = a let c = a let d = a let e = a (a, b, c, d, e) ================================================ FILE: tests/golden_tests/desugar_file/local_def_shadow.bend ================================================ def main: def A(): def B(): return 0 return B() def A(): def B(): return 1 return B() return A() ================================================ FILE: tests/golden_tests/desugar_file/main_aux.bend ================================================ def main: y = 89 def aux(x): def aux(x): def aux(x): return x + y return aux(x) return aux(x) return aux(2) ================================================ FILE: tests/golden_tests/desugar_file/mapper_syntax.bend ================================================ def main: x = 1 x @= lambda x: x + 1 map = { 0: 3, 1: 4 } map[1] += 1 map[1] @= lambda x: x * 2 return (x, map[1], map[0]) ================================================ FILE: tests/golden_tests/desugar_file/switch_with_use.bend ================================================ # Test manual linearization of a use term main = @x @y use z = (x y); @a @b @c switch a with z { 0: z _: (a-1 z) } ================================================ FILE: tests/golden_tests/desugar_file/tree_syntax.bend ================================================ fun0 = ![!0 ![!1 ![!2, !3]]] fun1 = !(![!*!*]) fun2 = !!!* fun3 = !1 fun4 = @n switch n { 0: !0 _: ![(fun4 n-1) (fun4 n-1)] } def imp0: return ![!0, ![!1, ![!2, !3]]] def imp1: return !(![!*,!*]) def imp2: return !!!* def imp3: return !1 def imp4(n): switch n: case 0: return !0 case _: return ![imp4(n-1), imp4(n-1)] main = * ================================================ FILE: tests/golden_tests/desugar_file/use_id.bend ================================================ (Main) = use id = use id = 2 (@x x id use id = 3; id) ; use id = (id id) (id id) ================================================ FILE: tests/golden_tests/desugar_file/use_shadow.bend ================================================ main = @a use b = (a a) @a (b a) ================================================ FILE: tests/golden_tests/desugar_file/used_once_names.bend ================================================ foo a b c = (a b (c c)) main = (foo 2 3 @x x) ================================================ FILE: tests/golden_tests/encode_pattern_match/adt_tup_era.bend ================================================ type Tuple = (Pair a b) (Foo (Tuple/Pair (Tuple/Pair a b) c)) = a (Foo *) = 2 Main = (Foo (Tuple/Pair 1 5)) ================================================ FILE: tests/golden_tests/encode_pattern_match/and3.bend ================================================ type Bool = T | F And (Bool/T, Bool/T, Bool/T) = Bool/T And * = Bool/F main = (And (Bool/F, Bool/T, Bool/F)) ================================================ FILE: tests/golden_tests/encode_pattern_match/bool.bend ================================================ type bool = true | false not bool/false = bool/true not bool/true = bool/false and bool/false bool/false = bool/false and bool/false bool/true = bool/false and bool/true bool/false = bool/false and bool/true bool/true = bool/true and2 bool/true b = b and2 bool/false b = bool/false and3 bool/true bool/true = bool/true and3 a b = bool/false and4 bool/false b = bool/false and4 a bool/false = bool/false and4 a b = bool/true ================================================ FILE: tests/golden_tests/encode_pattern_match/bool_tup.bend ================================================ type Bool = T | F foo (Bool/T, x) = x foo * = Bool/F main = (foo (Bool/F, Bool/T)) ================================================ FILE: tests/golden_tests/encode_pattern_match/box.bend ================================================ type box = (new val) unbox (box/new val) = val unbox x = x ================================================ FILE: tests/golden_tests/encode_pattern_match/common.bend ================================================ type Box = (Filled value) | Empty type Option = (Some x) | None type Result_ = (Ok a) | (Err b) type List_ = (Cons x xs) | Nil type Bool = True | False type Light = Red | Yellow | Green type Direction = North | South | East | West ================================================ FILE: tests/golden_tests/encode_pattern_match/concat.bend ================================================ String/concat = @a @b match a { String/nil: b; String/cons: (String/cons a.head (String/concat a.tail b)) } main = (String/concat "ab" "cd") ================================================ FILE: tests/golden_tests/encode_pattern_match/concat_def.bend ================================================ concat (String/Nil) str = str concat (String/Cons c rest1) str2 = (String/Cons c (concat rest1 str2)) main = (concat "ab" "cd") ================================================ FILE: tests/golden_tests/encode_pattern_match/def_tups.bend ================================================ go (a, (b, (c, (d, e)))) = (+ (+ (+ (+ e d) c) b) a) main = (go (1, (2, (3, (4, 5))))) ================================================ FILE: tests/golden_tests/encode_pattern_match/definition_merge.bend ================================================ type Either = (Left value) | (Right value) type Bool = True | False Foo (Either/Left Bool/False) (Either/Left Bool/False) = 1 Foo (Either/Left Bool/False) (Either/Left Bool/True) = 1 Foo (Either/Left Bool/True) (Either/Left Bool/False) = 1 Foo (Either/Left Bool/True) (Either/Left Bool/True) = 1 Foo (Either/Left Bool/False) (Either/Right Bool/False) = 2 Foo (Either/Left Bool/False) (Either/Right Bool/True) = 2 Foo (Either/Left Bool/True) (Either/Right Bool/False) = 2 Foo (Either/Left Bool/True) (Either/Right Bool/True) = 2 Foo (Either/Right Bool/False) (Either/Right Bool/False) = 3 Foo (Either/Right Bool/False) (Either/Right Bool/True) = 3 Foo (Either/Right Bool/True) (Either/Right Bool/False) = 3 Foo (Either/Right Bool/True) (Either/Right Bool/True) = 3 Foo (Either/Right Bool/False) (Either/Left Bool/False) = 3 Foo (Either/Right Bool/False) (Either/Left Bool/True) = 3 Foo (Either/Right Bool/True) (Either/Left Bool/False) = 3 Foo (Either/Right Bool/True) (Either/Left Bool/True) = 3 ================================================ FILE: tests/golden_tests/encode_pattern_match/expr.bend ================================================ type Expr = (Var name) | (Num val) | (App fun arg) | (Fun name body) | (If cond then else) | (Let bind val next) | (Dup fst snd val next) | (Tup fst snd) | (Op2 op fst snd) type Op = Add | Sub | Mul | Div ================================================ FILE: tests/golden_tests/encode_pattern_match/flatten_era_pat.bend ================================================ # To check that flattening works with Era patterns. (Fn1 (*,(a,*)) *) = a (Fn2 (*,(*,(a,*)))) = a (Fn3 (0,*) *) = 0 (Fn3 (a,*) *) = a main = (Fn2 ((1, 2), (3, (4, (5, 6)))) 0) ================================================ FILE: tests/golden_tests/encode_pattern_match/full_map.bend ================================================ def prng(state): state = state ^ (state << 13) state = state ^ (state >> 17) state = state ^ (state << 5) return state def fullMap: bend i = 14: when i > 0: return Map/Node(1, fork(i - 1), fork(i - 1)) else: return Map/Leaf def test(map): bend i = 0, map: when i < 1000: (curr, map) = Map/get(map, prng(i) % 4096) return curr+fork(i + 1, map) else: return 0 def main: return test(fullMap) ================================================ FILE: tests/golden_tests/encode_pattern_match/is_some_some.bend ================================================ type Option = (Some x) | (None) some_some (Option/Some (Option/Some x)) = 1 some_some * = 0 main = (some_some (Option/Some 1)) ================================================ FILE: tests/golden_tests/encode_pattern_match/list_merge_sort.bend ================================================ type Bool = True | False type List_ = (Cons head tail) | Nil If Bool/True then else = then If Bool/False then else = else Pure x = (List_/Cons x List_/Nil) Map List_/Nil f = List_/Nil Map (List_/Cons h t) f = (List_/Cons (f h) (Map t f)) MergeSort cmp xs = (Unpack cmp (Map xs Pure)) Unpack cmp List_/Nil = List_/Nil Unpack cmp (List_/Cons h List_/Nil) = h Unpack cmp xs = (Unpack cmp (MergePair cmp xs)) MergePair cmp (List_/Cons h1 (List_/Cons h2 t)) = (List_/Cons (Merge cmp h1 h2) (MergePair cmp t)) MergePair cmp xs = xs Merge cmp List_/Nil ys = ys Merge cmp xs List_/Nil = xs Merge cmp (List_/Cons xh xt) (List_/Cons yh yt) = (If (cmp xh yh) let ys = (List_/Cons yh yt) (List_/Cons xh (Merge cmp xt ys)) let xs = (List_/Cons xh xt) (List_/Cons yh (Merge cmp xs yt)) ) ================================================ FILE: tests/golden_tests/encode_pattern_match/list_str_encoding_undeclared_fn.bend ================================================ main = * Foo String/Nil = 0 Foo * = 1 Bar (List/Cons h t) = 0 Bar * = 1 ================================================ FILE: tests/golden_tests/encode_pattern_match/list_str_encoding_undeclared_map.bend ================================================ main = @a @b let a = match a { String/Cons: 1 String/Nil : 2 }; let b = match b { List/Cons: 1 List/Nil : 2 }; (a, b) ================================================ FILE: tests/golden_tests/encode_pattern_match/match_adt_unscoped_in_arm.bend ================================================ # Test that we don't mess up with that unscoped lambda/var type bool = T | F main = @x match x { Bool/T: @$x $x Bool/F: @x x } ================================================ FILE: tests/golden_tests/encode_pattern_match/match_adt_unscoped_lambda.bend ================================================ type Maybe_ = None | (Some val) main = (match x = (Maybe_/Some 1) { Maybe_/None: @$x * Maybe_/Some: x.val } $x) ================================================ FILE: tests/golden_tests/encode_pattern_match/match_adt_unscoped_var.bend ================================================ type Maybe_ = None | (Some val) Foo = @$x match x = (Maybe_/Some 1) { Maybe_/None: $x Maybe_/Some: x.val } Bar = (match x = (Maybe_/Some 1) { Maybe_/None: $x Maybe_/Some: x.val } @$x *) main = * ================================================ FILE: tests/golden_tests/encode_pattern_match/match_auto_linearization.bend ================================================ # Given a match/switch term preceded by a sequence of terms with binds (lambda, let, use, etc), # by default we linearize all bindings up to the first one that appears in the match "header". switch_linearization = @a @b let c = 2; let {c1 c2} = c; use d = (a, b); let (e, f) = d; switch a { 0: (b c c1 c2 d e f) _: (a-1 b c c1 c2 d e f) } match_linearization = @a @b let c = 2; let {c1 c2} = c; use d = (a, b); let (e, f) = d; match a { Nat/Zero: (b c c1 c2 d e f) Nat/Succ: (a.pred b c c1 c2 d e f) } switch_shadowed_field = @a @a-1 switch a { 0: a-1 _: a-1 } match_shadowed_field = @a @a.head @a.tail match a { List/Nil: (List/Cons a.head a.tail) List/Cons: (List/Cons a.head a.tail) } ================================================ FILE: tests/golden_tests/encode_pattern_match/match_bind.bend ================================================ cheese = switch num = (+ 2 3) { | 0: 653323 | _: (+ num num-1) } main = cheese ================================================ FILE: tests/golden_tests/encode_pattern_match/match_num_adt_tup_parser.bend ================================================ # Testing various forms of pattern matching type Result_ = (Ok val) | (Err err) Parse state (String/Cons '(' xs) = (Result_/Ok ('(', xs, state)) Parse state (String/Cons ')' xs) = (Result_/Ok (')', xs, state)) Parse state (String/Cons '\n' xs) = (Result_/Ok (0, xs, state)) Parse state xs = (Result_/Err (xs, state)) main = let str = "(+"; let state = *; match res = (Parse state str) { Result_/Ok: let (val, xs, state) = res.val; (val, (Parse state xs)) err: err } ================================================ FILE: tests/golden_tests/encode_pattern_match/match_num_pred.bend ================================================ pred = @n switch n { 0: 0 _: n-1 } pred2 n = switch n { 0: 0 1: 0 _: n-2 } pred3 0 = 0 pred3 1 = 0 pred3 2 = 0 pred3 x = (- x 3) zero 0 = 1 zero 1 = 0 zero * = 0 main = * ================================================ FILE: tests/golden_tests/encode_pattern_match/match_syntax.bend ================================================ type List_ = (Cons x xs) | (Nil) head x = match x { | List_/Nil: List_/Nil List_/Cons: x.x; } ================================================ FILE: tests/golden_tests/encode_pattern_match/merge_recursive.bend ================================================ foo_1 = @x (x foo_2) foo_2 = @a @b (a, b) bar_1 = @x (x bar_2) bar_2 = @a @b (a, b) ================================================ FILE: tests/golden_tests/encode_pattern_match/no_patterns.bend ================================================ Id x = x Id2 = @x x Pair a b = (a, b) ================================================ FILE: tests/golden_tests/encode_pattern_match/non_matching_fst_arg.bend ================================================ type bool = true | false Foo x bool/false = x Foo x bool/true = (Foo x x) ================================================ FILE: tests/golden_tests/encode_pattern_match/ntup_sum.bend ================================================ ntupSum (a, b, c, d, e) = (+ a (+ b (+ c (+ d e)))) main = (ntupSum (1, 3, 3, 2, 1)) ================================================ FILE: tests/golden_tests/encode_pattern_match/pattern_match_encoding.bend ================================================ type MyType = (A a) | (B b) | (C c) | (D d1 d2) | (E e1 e2) Foo (MyType/A a) = 100 Foo * = 200 main = (Foo MyType/A 2) ================================================ FILE: tests/golden_tests/encode_pattern_match/switch_in_switch_arg.bend ================================================ main x = switch x = (switch x {0: 0; _: x-1}) { 0: 0 _: x } ================================================ FILE: tests/golden_tests/encode_pattern_match/var_only.bend ================================================ type Bool = False | True (Foo a b) = λf (f a) (Foo a b) = b main = @x match x { false: Foo true: Bool/False } ================================================ FILE: tests/golden_tests/encode_pattern_match/weekday.bend ================================================ type Weekday = Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday main = (@x x Weekday/Saturday) ================================================ FILE: tests/golden_tests/hangs/bad_dup_interaction.bend ================================================ # A net that expands inifinitely like church exponentiation # Compiles to this net: # a # & ({(b c) (d b)} (c d)) ~ {(e a) e} main = let {a1 a2} = @b let {b1 b2} = b let (c1, c2) = b2 ((b1 c2), c1) (a1 a2) ================================================ FILE: tests/golden_tests/hangs/recursive_with_unscoped.bend ================================================ # Impossible to extract/linearize so that it does not hang when running Foo = @x (x ({Foo @$unscoped *} *) $unscoped) main = (Foo *) ================================================ FILE: tests/golden_tests/import_system/import_ctr_syntax.bend ================================================ from lib/ctr_type import Ctr main = (Ctr/Foo 2 3) ================================================ FILE: tests/golden_tests/import_system/import_main.bend ================================================ import lib/import_entry def main(): return * ================================================ FILE: tests/golden_tests/import_system/import_main2.bend ================================================ import lib/import_entry2 def main(): return * ================================================ FILE: tests/golden_tests/import_system/import_main3.bend ================================================ import lib/folder/import_entry3 def main(): return * ================================================ FILE: tests/golden_tests/import_system/import_type.bend ================================================ from lib/MyOption import (MyOption, MyOption/bind, MyOption/wrap) unwrap (val : (MyOption u24)) : u24 unwrap (MyOption/Some x) = x unwrap (MyOption/None) = 0 def main() -> MyOption((u24, u24)): with MyOption: a <- MyOption/Some(1) b = unwrap(MyOption/Some(2)) return wrap((a, b)) ================================================ FILE: tests/golden_tests/import_system/import_types.bend ================================================ from lib/types import (Bool, MyTree) from lib import bool_xor def tree_xor(tree): fold tree: case MyTree/node: return bool_xor(tree.lft, tree.rgt); case MyTree/leaf: return tree.val; main = let depth = 10 let tree = bend n = 0 { when (< n depth): (MyTree/node (fork (+ n 1)) (fork (+ n 1))) else: if (% n 2) { (MyTree/leaf Bool/True) } else { (MyTree/leaf Bool/False) } } (tree_xor tree) ================================================ FILE: tests/golden_tests/import_system/imports.bend ================================================ from lib/nums import (one, two) from lib/defs import sum def main(): return sum(one, two) ================================================ FILE: tests/golden_tests/import_system/imports_alias.bend ================================================ from lib/nums import (one as One, two as Two) from lib/defs import (sum as summation) def main(): return summation(One, Two) ================================================ FILE: tests/golden_tests/import_system/imports_alias_shadow.bend ================================================ from lib/nums import (one as A, two as A) def main(): return A + A ================================================ FILE: tests/golden_tests/import_system/imports_conflict.bend ================================================ from lib/a/b import C from lib/a import b/C lib/a/b/C = * def main(): return * ================================================ FILE: tests/golden_tests/import_system/imports_file_and_dir.bend ================================================ from lib/file_and_dir import (x, y) def main(): return (x, y, y/z) ================================================ FILE: tests/golden_tests/import_system/imports_file_and_dir_conflict.bend ================================================ from lib/file_and_dir import * def main(): return w ================================================ FILE: tests/golden_tests/import_system/imports_shadow.bend ================================================ from lib/folder import myFun from lib import myFun def main(): return myFun ================================================ FILE: tests/golden_tests/import_system/imports_shadow2.bend ================================================ from lib import myFun from lib/folder import myFun def main(): return myFun(lib/myFun/myFun) # use the full name to call a shadowed imported def ================================================ FILE: tests/golden_tests/import_system/lib/MyOption.bend ================================================ type MyOption(A): Some { val: A } None def MyOption/bind(val: MyOption(A), nxt: (Id -> Id) -> A -> MyOption(B)) -> MyOption(B): match val: case MyOption/Some: nxt = undefer(nxt) return nxt(val.val) case MyOption/None: return MyOption/None def MyOption/wrap(val: A) -> MyOption(A): return MyOption/Some(val) ================================================ FILE: tests/golden_tests/import_system/lib/a/b.bend ================================================ C = * ================================================ FILE: tests/golden_tests/import_system/lib/a.bend ================================================ type b = C ================================================ FILE: tests/golden_tests/import_system/lib/bool_xor.bend ================================================ from lib/types import Bool (bool_xor Bool/True Bool/False) = Bool/True (bool_xor Bool/False Bool/True) = Bool/True (bool_xor * *) = Bool/False ================================================ FILE: tests/golden_tests/import_system/lib/ctr_type.bend ================================================ # Test issue #674 type Ctr: Foo { x, y } def Ctr/wrap(x): return Ctr/Foo { x: x, y: 0 } ================================================ FILE: tests/golden_tests/import_system/lib/defs.bend ================================================ def sum(a, b): return a + b def minus(a, b): return a - b ================================================ FILE: tests/golden_tests/import_system/lib/file_and_dir/w.bend ================================================ w = 5 ================================================ FILE: tests/golden_tests/import_system/lib/file_and_dir/y.bend ================================================ y = 3 z = 4 ================================================ FILE: tests/golden_tests/import_system/lib/file_and_dir.bend ================================================ x = 1 w = 2 ================================================ FILE: tests/golden_tests/import_system/lib/folder/import_entry3.bend ================================================ import ../../../../import_main3 # multiples ../ have no effect past the main file folder ================================================ FILE: tests/golden_tests/import_system/lib/folder/myFun.bend ================================================ def myFun(a): return a ================================================ FILE: tests/golden_tests/import_system/lib/import_entry.bend ================================================ import import_main ================================================ FILE: tests/golden_tests/import_system/lib/import_entry2.bend ================================================ import ../import_main2 ================================================ FILE: tests/golden_tests/import_system/lib/myFun.bend ================================================ type Type = (A) | (B) def myFun(a): match a: case Type/A: return 1 case Type/B: return 2 ================================================ FILE: tests/golden_tests/import_system/lib/nums.bend ================================================ def one(): return 1 two = 2 def three(): return 3 ================================================ FILE: tests/golden_tests/import_system/lib/types.bend ================================================ type Bool: True False type MyTree = (node ~lft ~rgt) | (leaf val) ================================================ FILE: tests/golden_tests/io/eof.txt ================================================ text ================================================ FILE: tests/golden_tests/io/load.bend ================================================ (Main): (IO (Result String u24)) = use path = "tests/golden_tests/io/load.txt" with IO { ask file = (IO/FS/read_file path) match file { Result/Err: (wrap (Result/Err (file.val))) Result/Ok: (wrap (Result/Ok (String/decode_utf8 file.val))) } } ================================================ FILE: tests/golden_tests/io/load.txt ================================================ Contents ================================================ FILE: tests/golden_tests/io/load_fail.bend ================================================ (Main) : (IO (Result String u24)) = use path = "tests/golden_tests/io/missing_dir/load_fail.txt" with IO { ask file = (IO/FS/read_file path) match file { Result/Err: (wrap (Result/Err (file.val))) Result/Ok: (wrap (Result/Ok (String/decode_utf8 file.val))) } } ================================================ FILE: tests/golden_tests/io/read_line_eof.bend ================================================ def main() -> IO(String): with IO: fd <- IO/FS/open("tests/golden_tests/io/eof.txt", "r") match fd: case Result/Err: return wrap(append("Err: ", u24/to_string(fd.val))) case Result/Ok: bytes <- IO/FS/read_line(fd.val) match bytes: case Result/Err: return wrap(append("Err: ", u24/to_string(bytes.val))) case Result/Ok: txt = String/decode_utf8(bytes.val) return wrap(txt) append (String/Nil) str = str append (String/Cons x xs) str = (String/Cons x (append xs str)) ================================================ FILE: tests/golden_tests/io/store.bend ================================================ (Main) : (IO (Result None u24)) = use path = "tests/golden_tests/io/store.txt" with IO { (IO/FS/write_file path (String/encode_utf8 "(Main) = 0")) } ================================================ FILE: tests/golden_tests/io/store.txt ================================================ (Main) = 0 ================================================ FILE: tests/golden_tests/io/store_fail.bend ================================================ (Main) : (IO (Result None u24)) = use path = "tests/golden_tests/io/missing_dir/store_fail.txt" with IO { (IO/FS/write_file path (String/encode_utf8 "(Main) = 0")) } ================================================ FILE: tests/golden_tests/io/utf8.bend ================================================ to-and-back s = (String/decode_utf8 (String/encode_utf8 s)) v1 = (to-and-back "hi") v2 = (to-and-back "(λf ((λx (f (x x))) (λx (f (x x)))))") v3 = (to-and-back "🌟") v4 = (to-and-back "Hello 🌎!") v5 = (to-and-back "𓆈 𓆉 𓆊 𓆋 𓅯") v6 = (String/decode_utf8 []) main = [v1, v2, v3, v4, v5, v6] ================================================ FILE: tests/golden_tests/linear_readback/church_mul.bend ================================================ C_2 = λa λb (a (a b)) C_3 = λa λb (a (a (a b))) Mult = λm λn λs λz (m (n s) z) main = (Mult C_2 C_3) ================================================ FILE: tests/golden_tests/mutual_recursion/a_b_c.bend ================================================ (A) = (B) (B) = (C) (C) = (A) (Main) = (A) ================================================ FILE: tests/golden_tests/mutual_recursion/len.bend ================================================ (Len []) = 0 (Len (List/Cons _ tail)) = (+ 1 (Len tail)) (Main) = (Len [* * * * * *]) ================================================ FILE: tests/golden_tests/mutual_recursion/merged.bend ================================================ (X x) = (Rec x) (Y x) = (Rec x) (Rec x) = (X x) (Rec2 x) = (X x) (Main) = (Y 0) ================================================ FILE: tests/golden_tests/mutual_recursion/multiple.bend ================================================ (A) = (B) (B) = (C) (C) = (A) (H) = (I) (I) = (H) (N x) = (x (N x)) (M) = (M) (Main) = * ================================================ FILE: tests/golden_tests/mutual_recursion/odd_even.bend ================================================ type Bool = True | False (if_ 0 then else) = else (if_ _ then else) = then (isOdd n) = (if_ (== n 0) Bool/False (isEven (- n 1))) (isEven n) = (if_ (== n 0) Bool/True (isOdd (- n 1))) (Main) = (isOdd 4) ================================================ FILE: tests/golden_tests/parse_file/bad_floating.bend ================================================ def main: return 0xA.0xA ================================================ FILE: tests/golden_tests/parse_file/bend_missing_else.bend ================================================ def is_even(n): if n % 2 == 0: return 1 else: return 0 def get_even_sum_under_if(this_number): bend current = 0: when current < this_number: new_num = fork(current + is_even(current)) return new_num def main(): return get_even_sum_under_if(1000) ================================================ FILE: tests/golden_tests/parse_file/era.bend ================================================ (Main) = (*) ================================================ FILE: tests/golden_tests/parse_file/fold_missing_case.bend ================================================ def main: fold [] with x = 1: ================================================ FILE: tests/golden_tests/parse_file/fun_def.bend ================================================ main = let base = 0 def aux [] = base aux (List/Cons head tail) = (+ head (aux tail)) (aux [1, 2, 3]) ================================================ FILE: tests/golden_tests/parse_file/fun_def_name.bend ================================================ main = let base = 0 def aux [] = base aux2 (List/Cons head tail) = (+ head (aux tail)) (aux [1, 2, 3]) ================================================ FILE: tests/golden_tests/parse_file/if_missing_else.bend ================================================ def main: if 1 == 1: return "true" ================================================ FILE: tests/golden_tests/parse_file/imp_map.bend ================================================ def main(): x = { 2: 1, 3: 2 }; y = id(x[2]); z = 4; x[z] = 4; return y + x[z]; ================================================ FILE: tests/golden_tests/parse_file/imp_program.bend ================================================ type Point: Point { x, y } type Bool: True False def symbols(): x = { `x`: 5, 2: 3 }; x[`x`] = 2; x[2] = 3; return x[`x`] + `foxy`; def mk_point(): return Point/Point(y = 2, x = 1); def identity(x): return x; def inc(n): n += 1; return n; def inc_list(list): return [x+1 for x in list]; def lam(): return lambda x, y: x; def do_match(b): match b: case Bool/True: return 1; case Bool/False: return 0; def true(): return Bool/True; def fib(n): if n < 2: return n; else: return fib(n - 1) + fib(n - 2); def swt(n): switch n: case 0: return 42; case _: return 1; def fld(list): fold list: case List/Cons: return 1; case List/Nil: return 2; def bnd(): bend x = 0: when x < 10: return List/Cons(x, fork(x + 1)); else: return List/Nil(); def era(): * = (2 + 3) the_expr_killer = * return the_expr_killer(9) def sup(): x = {[1, 2], [3, 4, 5, 6]} return x def main(): with IO: x <- IO.read(); return x; ================================================ FILE: tests/golden_tests/parse_file/match_missing_case.bend ================================================ def main: match []: ================================================ FILE: tests/golden_tests/parse_file/multi_line_comment.bend ================================================ #{ #} def main: #{ ok #}# # return 0 #{foo type#} type Foo: #{foo constructor#} Foo { foo } #{bar type#} object Bar { bar } #{ # ignore #}# #{X x x x#} (X x x x) = #{ x #} x #{ x #} #{V#} type V = #{V constructor#} V (String/is_empty s) = #{test if string is nil#} match s #{ #}{ String/Nil: 1 String/Cons: 0 } def String/not_empty(s): #{test if string if not nil#} match s: #{ its not #} case String/Nil: return 0 case String/Cons: #{ it is#} return 1 ================================================ FILE: tests/golden_tests/parse_file/redefinition_builtin.bend ================================================ def Map/get(m): return m ================================================ FILE: tests/golden_tests/parse_file/redefinition_ctr_with_fun.bend ================================================ def String/Cons(x): return x ================================================ FILE: tests/golden_tests/parse_file/redefinition_fun_imp.bend ================================================ # We shouldn't allow a fun rule to be extended by an imp function (A) = @x x def A: return 0 ================================================ FILE: tests/golden_tests/parse_file/redefinition_imp_fun.bend ================================================ # We shouldn't allow an imp function to have a fun rule def A: return 0 (A) = 1 ================================================ FILE: tests/golden_tests/parse_file/redefinition_type_with_object.bend ================================================ object IO { run } ================================================ FILE: tests/golden_tests/parse_file/redefinition_with_def_between.bend ================================================ # We shouldn't allow rules of other functions in the middle of a definition (A) = @x x (B) = @x x (A) = @x x ================================================ FILE: tests/golden_tests/parse_file/redefinition_with_object_between.bend ================================================ A = 0 object B A = 1 ================================================ FILE: tests/golden_tests/parse_file/redefinition_with_type_between.bend ================================================ A = 0 type MyType = MyType A = 1 ================================================ FILE: tests/golden_tests/parse_file/repeated_adt_name.bend ================================================ type Foo = A type Foo = B main = * ================================================ FILE: tests/golden_tests/parse_file/repeated_datatype_name.bend ================================================ type Expr = (Lit Int) | (Plus Expr Expr) eval (Expr/Lit i) = i eval (Expr/Plus l r) = (+ (eval l) (eval r)) main = (eval (Expr/Plus (Expr/Lit 80) (Expr/Lit 90))) ================================================ FILE: tests/golden_tests/parse_file/scape_chars.bend ================================================ main = "\\ \n \t \"" ================================================ FILE: tests/golden_tests/parse_file/strange_pattern.bend ================================================ main & = (a b c) ================================================ FILE: tests/golden_tests/parse_file/tab.bend ================================================ def main: x = 2 return x + 1 ================================================ FILE: tests/golden_tests/parse_file/tup_with_signed.bend ================================================ # Test that we can parse tuples and apps beginning with signed numbers main = let a = (+1, +1) let b = (+1.1324) let c = (-6.234, -1) let d = (-1) let e = (+6 * λx x) let f = ((*) λx x) (+ a (+ b (+ c (+ d (- e f))))) ================================================ FILE: tests/golden_tests/parse_file/tuple_assign.bend ================================================ def main: first, second = 1, (2, 3) return second ================================================ FILE: tests/golden_tests/parse_file/tuple_commas.bend ================================================ def main: tup = fst(1, lambda x: x), 2 return tup, 3, (4, 5) def fst(x, y): return x ================================================ FILE: tests/golden_tests/parse_file/tuple_need_parens.bend ================================================ def main: if 1, 2: return "not" else: return "hmmm" ================================================ FILE: tests/golden_tests/prelude/applies_function_to_map.bend ================================================ # Checks if a generic map contains a given key, and if it does, applies a function to the value, otherwise it returns the map def test(m: Map(u24), key: u24) -> u24: def addtwo (x: u24) -> u24: return (x + 2) (num, map) = Map/contains(m, key) if (num == 0): return unreachable() else: m = Map/map(m, key, addtwo()) (value, map) = Map/get(m, key) return value def main() -> _: m = {3: 255} return test(m, 3) ================================================ FILE: tests/golden_tests/prelude/get_values_from_map.bend ================================================ def test1() -> (u24): m = {} m = Map/set(Map/set(Map/set(Map/empty, 3, 4), 2, 3), 1, 2) (val1, map1) = Map/get(m, 1) (val2, map2) = Map/get(map1, val1) return val2 def main() -> _: return test1() ================================================ FILE: tests/golden_tests/prelude/lists_to_map.bend ================================================ # Takes two lists and uses one as keys and the other as values, returning a map def test(m: Map(T), xs: List(u24), ys: List(T)) -> Map(T): match xs: case List/Nil: return Map/Leaf case List/Cons: match ys: case List/Nil: return Map/Leaf case List/Cons: return test(Map/set(m, xs.head, ys.head), xs.tail, ys.tail) def main() -> _: return test(Map/Leaf, List/Cons(1, List/Nil), List/Cons(2, List/Nil)) ================================================ FILE: tests/golden_tests/prelude/map_checked_test.bend ================================================ #Tests the get_check function def main() -> _: m1 = {0: 1, 3: 2} return Map/get_check(m1, 3) ================================================ FILE: tests/golden_tests/prelude/map_contains_test.bend ================================================ def main() -> _: m1 = {0: 23} return Map/contains(m1, 3) ================================================ FILE: tests/golden_tests/prelude/set_node_when_empty.bend ================================================ # Sets a value if the given node is empty, otherwise returns the map def test(m: Map(T), x: u24, v: T) -> Map(T): (val, map) = Map/get_check(m, x) match val: case Maybe/Some: return m case Maybe/None: return Map/set(m, x, v) def main() -> _: m = {0: 42, 1:23} return test(m, 3, 4) ================================================ FILE: tests/golden_tests/readback_hvm/addition.bend ================================================ a & [+2] ~ $(1 a) ================================================ FILE: tests/golden_tests/readback_hvm/bad_net.bend ================================================ b ================================================ FILE: tests/golden_tests/readback_hvm/bad_net1.bend ================================================ (a b) & {c b} ~ (c a) ================================================ FILE: tests/golden_tests/readback_hvm/bad_net3.bend ================================================ ({a b} (b a)) ================================================ FILE: tests/golden_tests/readback_hvm/complicated_dup.bend ================================================ ({(a b) (c d)} e) & ((f {a c}) b) ~ ((f d) e) ================================================ FILE: tests/golden_tests/readback_hvm/fst_snd.bend ================================================ a & (b a) ~ ({* c} c) & ({{1 3} 2} b) ~ ({d *} d) ================================================ FILE: tests/golden_tests/readback_hvm/id.bend ================================================ (a a) ================================================ FILE: tests/golden_tests/readback_hvm/invalid_op2_op2.bend ================================================ (a b) & 1 ~ (c d) & $([+1] $(d b)) ~ $(c a) ================================================ FILE: tests/golden_tests/readback_hvm/match.bend ================================================ a & 1 ~ ?(((b b) (c c)) a) ================================================ FILE: tests/golden_tests/readback_hvm/nested_let.bend ================================================ a & {{* *} {a *}} ~ {{2 4} {3 6}} ================================================ FILE: tests/golden_tests/readback_hvm/nested_tup.bend ================================================ {{1 2} {4 {3 5}}} ================================================ FILE: tests/golden_tests/readback_hvm/number.bend ================================================ 10 ================================================ FILE: tests/golden_tests/readback_hvm/simple_tup.bend ================================================ {0 42} ================================================ FILE: tests/golden_tests/readback_hvm/tup_add.bend ================================================ a & {b c} ~ {1 2} & [+] ~ $(b $(c a)) ================================================ FILE: tests/golden_tests/run_entrypoint/foo.bend ================================================ bar = λx x foo = (bar 2) ================================================ FILE: tests/golden_tests/run_file/360_no_scope.bend ================================================ main = let $d = ((@$a $c) 360) let $b = ((@$c $a) $b) let #x{#y($e, $f) #y($g, $h)} = #y(#x{$d $f}, #x{$e, $g}) $h ================================================ FILE: tests/golden_tests/run_file/addition.bend ================================================ (main) = (λx (+ (+ 1 1) x) 8) ================================================ FILE: tests/golden_tests/run_file/adt_match.bend ================================================ type Opt = (Some x) | None Opt/map = @opt @f match opt { Opt/Some: (Opt/Some (f opt.x)); Opt/None: Opt/None } inc = @x (+ x 1) main = let opt = (Opt/Some 1); (Opt/map opt inc) ================================================ FILE: tests/golden_tests/run_file/adt_match_wrong_tag.bend ================================================ type Option = (Some val) | None main = λa #Option (a #wrong_tag λb b *) ================================================ FILE: tests/golden_tests/run_file/adt_option_and.bend ================================================ type Option = (Some val) | None main = @a @b match a { Option/Some: match b { Option/Some: (Option/Some (a.val, b.val)) Option/None: Option/None } Option/None: Option/None } ================================================ FILE: tests/golden_tests/run_file/adt_wrong_tag.bend ================================================ type Option = (Some val) | None main = (@a #Option (a #wrong_tag @x x *)) ================================================ FILE: tests/golden_tests/run_file/and.bend ================================================ type bool = true | false and a bool/false = bool/false and a bool/true = a main = (and bool/true bool/false) ================================================ FILE: tests/golden_tests/run_file/basic_num_ops.bend ================================================ List/expand (List/Cons h t) = (List/Cons h (List/expand t)) List/expand (List/Nil) = (List/Nil) main = (List/expand [ (+ 20 10) (- 20 10) (* 20 10) (/ 20 10) (% 20 10) (^ 20 10) (& 20 10) (| 20 10) (== 20 10) (!= 20 10) (< 20 10) (> 20 10) (<< 10 2) (>> 10 2) 0xFFFF (+ +20 +10) (- +20 +10) (* +20 +10) (/ +20 +10) (% +20 +10) (^ +20 +10) (& +20 +10) (| +20 +10) (== +20 +10) (!= +20 +10) (< +20 +10) (> +20 +10) 0xFFFF (+ -20 -10) (- -20 -10) (* -20 -10) (/ -20 -10) (% -20 -10) (^ -20 -10) (& -20 -10) (| -20 -10) (== -20 -10) (!= -20 -10) (< -20 -10) (> -20 -10) 0xFFFF (+ +20 -10) (- +20 -10) (* +20 -10) (/ +20 -10) (% +20 -10) (^ +20 -10) (& +20 -10) (| +20 -10) (== +20 -10) (!= +20 -10) (< +20 -10) (> +20 -10) 0xFFFF (+ -20 +10) (- -20 +10) (* -20 +10) (/ -20 +10) (% -20 +10) (^ -20 +10) (& -20 +10) (| -20 +10) (== -20 +10) (!= -20 +10) (< -20 +10) (> -20 +10) 0xFFFF (+ +20.0 +10.0) (- +20.0 +10.0) (* +20.0 +10.0) (/ +20.0 +10.0) (% +20.0 +10.0) (^ +20.0 +10.0) (& +20.0 +10.0) (| +20.0 +10.0) (== +20.0 +10.0) (!= +20.0 +10.0) (< +20.0 +10.0) (> +20.0 +10.0) 0xFFFF (+ -20.0 -10.0) (- -20.0 -10.0) (* -20.0 -10.0) (/ -20.0 -10.0) (% -20.0 -10.0) (^ -20.0 -10.0) (& -20.0 -10.0) (| -20.0 -10.0) (== -20.0 -10.0) (!= -20.0 -10.0) (< -20.0 -10.0) (> -20.0 -10.0) 0xFFFF (+ +20.0 -10.0) (- +20.0 -10.0) (* +20.0 -10.0) (/ +20.0 -10.0) (% +20.0 -10.0) (^ +20.0 -10.0) (& +20.0 -10.0) (| +20.0 -10.0) (== +20.0 -10.0) (!= +20.0 -10.0) (< +20.0 -10.0) (> +20.0 -10.0) 0xFFFF (+ -20.0 +10.0) (- -20.0 +10.0) (* -20.0 +10.0) (/ -20.0 +10.0) (% -20.0 +10.0) (^ -20.0 +10.0) (& -20.0 +10.0) (| -20.0 +10.0) (== -20.0 +10.0) (!= -20.0 +10.0) (< -20.0 +10.0) (> -20.0 +10.0) 0xFFFF (Math/log 2.0 3.0) (Math/atan2 3.0 4.0) ] ) ================================================ FILE: tests/golden_tests/run_file/bend_fold.bend ================================================ # should return (a+b+c) * 2^depth main = let depth = 2 let a = 1; let b = 2; let c = 3; let n = 0; let tree = bend n { when (< n depth): ![(fork (+ n 1)) (fork (+ n 1))] else: !c } fold tree { Tree/Node: (+ tree.left tree.right) Tree/Leaf: (+ tree.value (+ a b)) } ================================================ FILE: tests/golden_tests/run_file/bitonic_sort.bend ================================================ type Error = Err # Atomic Swapper (Swap n a b) = switch n { 0: (Tree/Node a b) _: (Tree/Node b a) } # Swaps distant values in parallel; corresponds to a Red Box (Warp s (Tree/Leaf a) (Tree/Leaf b)) = (Swap (^ (> a b) s) (Tree/Leaf a) (Tree/Leaf b)) (Warp s (Tree/Node a b) (Tree/Node c d)) = (Join (Warp s a c) (Warp s b d)) (Warp s a b) = Error/Err # Rebuilds the warped tree in the original order (Join (Tree/Node a b) (Tree/Node c d)) = (Tree/Node (Tree/Node a c) (Tree/Node b d)) (Join a b) = Error/Err # Recursively warps each sub-tree; corresponds to a Blue/Green Box (Flow s (Tree/Leaf a)) = (Tree/Leaf a) (Flow s (Tree/Node a b)) = (Down s (Warp s a b)) # Propagates Flow downwards (Down s (Tree/Leaf a)) = (Tree/Leaf a) (Down s (Tree/Node a b)) = (Tree/Node (Flow s a) (Flow s b)) # Bitonic Sort (Sort s (Tree/Leaf a)) = (Tree/Leaf a) (Sort s (Tree/Node a b)) = (Flow s (Tree/Node (Sort 0 a) (Sort 1 b))) # Generates a tree of depth `n` (Gen n x) = switch n { 0: (Tree/Leaf x) _: (Tree/Node (Gen n-1 (* x 2)) (Gen n-1 (+ (* x 2) 1))) } # Reverses a tree (Rev (Tree/Leaf x)) = (Tree/Leaf x) (Rev (Tree/Node a b)) = (Tree/Node (Rev b) (Rev a)) # Sums a tree (Sum (Tree/Leaf x)) = x (Sum (Tree/Node a b)) = (+ (Sum a) (Sum b)) Main = (Sum (Sort 0 (Rev (Gen 4 0)))) ================================================ FILE: tests/golden_tests/run_file/bitonic_sort_lam.bend ================================================ # type Tree = (Leaf x) | (Node x0 x1) Leaf = λx λl λn (l x) Node = λx0 λx1 λl λn (n x0 x1) swap = λn switch n { 0: λx0 λx1 (Node x0 x1) _: λx0 λx1 (Node x1 x0) } warp = λa let a_leaf = λax λb let b_leaf = λbx λax λs (swap (^ (> ax bx) s) (Leaf ax) (Leaf bx)) let b_node = λa0 λa1 λax λs 0 ((b b_leaf b_node) ax) let a_node = λa0 λa1 λb let b_leaf = λbx λa0 λa1 λs 0 let b_node = λb0 λb1 λa0 λa1 λs (join (warp a0 b0 s) (warp a1 b1 s)) ((b b_leaf b_node) a0 a1) (a a_leaf a_node) join = λa let a_leaf = λax λb 0 let a_node = λa0 λa1 λb let b_leaf = λbx λa0 λa1 0 let b_node = λb0 λb1 λa0 λa1 (Node (Node a0 b0) (Node a1 b1)) ((b b_leaf b_node) a0 a1) (a a_leaf a_node) flow = λa let a_leaf = λax λs (Leaf ax) let a_node = λa0 λa1 λs (down (warp a0 a1 s) s) (a a_leaf a_node) down = λa let a_leaf = λax λs (Leaf ax) let a_node = λa0 λa1 λs (Node (flow a0 s) (flow a1 s)) (a a_leaf a_node) sort = λa let a_leaf = λax λs (Leaf ax) let a_node = λa0 λa1 λs (flow (Node (sort a0 0) (sort a1 1)) s) (a a_leaf a_node) gen = λn switch n { 0: λx (Leaf x) _: λx (Node (gen n-1 (* x 2)) (gen n-1 (+ (* x 2) 1))) } rev = λa let a_leaf = λax (Leaf ax) let a_node = λa0 λa1 (Node (rev a1) (rev a0)) (a a_leaf a_node) sum = λa let a_leaf = λax ax let a_node = λa0 λa1 (+ (sum a0) (sum a1)) (a a_leaf a_node) main = (sum (sort (rev (gen 8 0)) 0)) ================================================ FILE: tests/golden_tests/run_file/box.bend ================================================ type _Box = (Box val) Box.subst (_Box/Box x) cmp to = switch _ = (cmp x) { 0: (_Box/Box x) _: (_Box/Box to) } Main = (Box.subst (_Box/Box 4) @x (== x 4) (_Box/Box 10)) ================================================ FILE: tests/golden_tests/run_file/branch_statements_assignment.bend ================================================ # Test that branching statements can end with an assignment type MyTree: node { val, ~lft, ~rgt } leaf def main: deep = 0 if deep: n = 20 else: n = 2 bend x = 1, h = 0: when h < n: y = MyTree/node { val: x, lft: fork(2 * x, h + 1), rgt: fork(2 * x + 1, h + 1) } else: y = MyTree/leaf fold y: case MyTree/node: z = y.val + y.lft + y.rgt case MyTree/leaf: z = 0 return z ================================================ FILE: tests/golden_tests/run_file/callcc.bend ================================================ (CC.lang program) = let callcc = λcallback (λ$garbage($hole) (callback λ$hole(0))) let result = (program callcc) let garbage = $garbage result Main = (CC.lang λcallcc (+ 10 (callcc λk(+ (k 42) 1729)))) ================================================ FILE: tests/golden_tests/run_file/chars.bend ================================================ main = (String/Cons '\u{1234}' (String/Cons '!' (String/Cons '7' String/Nil))) ================================================ FILE: tests/golden_tests/run_file/chars_forall.bend ================================================ main = '∀' ================================================ FILE: tests/golden_tests/run_file/chars_lambda.bend ================================================ main = 'λ' ================================================ FILE: tests/golden_tests/run_file/checked_scott_encoding.bend ================================================ checked (scott_concat a b) = (a λh λt λcons λnil (cons h (scott_concat t b)) b ) main = scott_concat ================================================ FILE: tests/golden_tests/run_file/comprehension.bend ================================================ def inc_list(list): return [x + 1 for x in list] def filter_gt(list, n): return [x for x in list if x > n] def main: list = [3, 4, 1, 9, 6, 5] list = inc_list(list) list = filter_gt(list, 4) return list ================================================ FILE: tests/golden_tests/run_file/def_bool_num.bend ================================================ type bool = true | false go bool/true 0 = 1 go bool/false _ = 0 main = (go bool/true 1) ================================================ FILE: tests/golden_tests/run_file/def_num_bool.bend ================================================ type bool = true | false go 0 bool/true = 1 go 0 bool/false = 0 main = (go 1 bool/true) ================================================ FILE: tests/golden_tests/run_file/def_tups.bend ================================================ go (a, (b, (c, (d, e)))) = (+ (+ (+ (+ e d) c) b) a) main = (go (1, (2, (3, (4, 5))))) ================================================ FILE: tests/golden_tests/run_file/do_block_mixed.bend ================================================ # Mixed contents in a `do` block should still work. Result/bind r nxt = match r { Result/Ok: ((undefer nxt) r.val) Result/Err: r } main = with Result { let x = 1 let y = (Result/Ok x) ask y = y if (+ x y) { ask w = (Result/Ok x) (Result/Ok w) } else { (Result/Err 0) } } ================================================ FILE: tests/golden_tests/run_file/dup_global_lam.bend ================================================ (main) = let {x1 x2} = $a; ((λ$a λb b) (x1 x2)) ================================================ FILE: tests/golden_tests/run_file/empty.bend ================================================ ================================================ FILE: tests/golden_tests/run_file/encode_decode_utf8.bend ================================================ def main: use bytes = [72, 101, 108, 108, 111, 44, 32, 228, 184, 150, 231, 149, 140, 33] use s = "Hello, 世界!" return (String/encode_utf8(s), String/decode_utf8(bytes)) ================================================ FILE: tests/golden_tests/run_file/erased_side_effect.bend ================================================ abc = @x let * = (x 123); * main = let * = (abc @$xyz *); $xyz ================================================ FILE: tests/golden_tests/run_file/escape_sequences.bend ================================================ String/from_list [] = "" String/from_list (List/Cons x xs) = (String/Cons x (String/from_list xs)) (Concat String/Nil ys) = ys (Concat (String/Cons x xs) ys) = (String/Cons x (Concat xs ys)) (Join List/Nil) = "" (Join (List/Cons x xs)) = (Concat x (Join xs)) (Expand xs) = fold xs { String/Nil: xs; String/Cons: xs } main = let a = (String/from_list ['\n', '\r', '\t', '\0', '\"', '\'', '\u{AFE}', '\\']) let b = (Join ["\n", "\r", "\t", "\0", "\"", "\'", "\u{AFE}", "\\"]) (Expand (Concat a b)) ================================================ FILE: tests/golden_tests/run_file/eta.bend ================================================ Id = λb b main = λa (Id a) ================================================ FILE: tests/golden_tests/run_file/example.bend ================================================ # Write definitions like this (Def1) = ((λa a) (λb b)) # You can call a definition by just referencing its name # It will be substituted in place of the reference (Def2) = ((λa a) Def1) # Definitions and variables can have names in upper and lower case and contain numbers # Names defined in a more inner position shadow names in an outer position (def3) = ((λDef1 Def1) (λx λx x)) # The language is affine, but if you use a variable more than once the compiler inserts duplications for you # Of course you can always do them manually (def4) = λz let {z1 z2} = z; (z1 ((λx (x x x x x)) z2)) # You can use machine numbers and some native numeric operations # Numeric operations can only reduce numbers, doing (+ (λx x) 1) will not do anything (nums) = λx1 λx2 (* (+ x1 1) (/ (- x2 2) 1)) # You can use numbers on the native match expression # The `+` arm binds the `scrutinee`-1 variable to the the value of the number -1 (Num.pred) = λn switch n { 0: 0 _: n-1 } # Write new data types like this type Option = (Some val) | None type Bool = True | False # You can have pattern matching on definitions # Use `*` to ignore a pattern (Option.unwrap_or (Option/Some val) *) = val (Option.unwrap_or Option/None or) = or (Bool.or Bool/True *) = Bool/True (Bool.or * Bool/True) = Bool/True (Bool.or * *) = Bool/False # Or using a match expression (Bool.not) = λbool match bool { Bool/True: Bool/False Bool/False: Bool/True } # Data types can store values type Boxed = (Box val) # Types with only one constructor can be destructured using `let` or a single matching definition (Box.map (Boxed/Box val) f) = (Boxed/Box (f val)) (Box.unbox) = λbox match box { Boxed/Box: box.val } # Use tuples to store two values together without needing to create a new data type (Tuple.new fst snd) = let pair = (fst, snd) pair # Then you can destructure it inside the definition or using `let` (Tuple.fst (fst, snd)) = fst (Tuple.snd) = λpair let (fst, snd) = pair snd # All files must have a main definition to be run. # You can execute a program in HVM with "cargo run -- run " # Other options are "check" (the default mode) to just see if the file is well formed # and "compile" to output hvm-core code. (main) = let tup = (Tuple.new Option/None (Num.pred 5)) let fst = (Tuple.fst tup) let snd = (Tuple.snd tup) let box = (Boxed/Box fst) let map = (Box.map box Option.unwrap_or) let unboxed = ((Box.unbox map) snd) (nums 3 unboxed) ================================================ FILE: tests/golden_tests/run_file/exp.bend ================================================ # Requires different labels in the two duplications of f main = ((λfλx (f (f x))) (λfλx (f (f x)))) ================================================ FILE: tests/golden_tests/run_file/expand_main_combinator.bend ================================================ # It should reduce to `@a (a 1 2)` if main is expanded correctly. # (ctr 1 2) should not be extracted from main into a separate function. main = my_fn my_fn = (@x x (ctr 1 2)) ctr = @a @b @x (x a b) ================================================ FILE: tests/golden_tests/run_file/expand_main_list.bend ================================================ # Should return [1, 2, 3] fn1 = (@x x 1) fn2 = (@x x 2) fn3 = (@x x 3) main = [fn1, fn2, fn3] ================================================ FILE: tests/golden_tests/run_file/extracted_match_pred.bend ================================================ # We expect the lambda 'p' from the match to be extracted which allows this recursive func val = λn (switch n { 0: valZ; _: (valS n-1) }) valZ = 0 valS = λp (val p) main = (val 1) ================================================ FILE: tests/golden_tests/run_file/filter_bool_id.bend ================================================ type Bool: T F def filter(f, ls): match ls: case List/Nil: return List/Nil case List/Cons: match f(ls.head): case Bool/T: return List/Cons(ls.head, filter(f, ls.tail)) case Bool/F: return filter(f, ls.tail) def main: return filter(lambda x: x, [Bool/T]) ================================================ FILE: tests/golden_tests/run_file/floating_numbers.bend ================================================ def main: return [0x12.129, 0x0.2, 0b101.101, 0xAAAAAAAA.AAAAAAAA, 0xA.__A__] ================================================ FILE: tests/golden_tests/run_file/fold_with_state.bend ================================================ def main: y = 1 fold x = [0, 0, 0] with y: case List/Cons: return List/Cons(x.head + y, x.tail(y + 1)) case List/Nil: return List/Nil ================================================ FILE: tests/golden_tests/run_file/guide_bend_7tree.bend ================================================ def main(): bend x = 0: when x < 3: tree = ![fork(x + 1), fork(x + 1)] else: tree = !7 return tree ================================================ FILE: tests/golden_tests/run_file/guide_bend_sequential.bend ================================================ def foo(_): bend idx = 0: when idx < 10: sum = idx + fork(idx + 1) else: sum = 0 return sum def main: return foo(*) ================================================ FILE: tests/golden_tests/run_file/guide_bend_sum_tree.bend ================================================ def main(): bend d = 0, i = 0: when d < 15: # in the guide its 28, but that takes way too long sum = fork(d+1, i*2+0) + fork(d+1, i*2+1) else: sum = i return sum ================================================ FILE: tests/golden_tests/run_file/guide_bitonic_sort.bend ================================================ def gen(d, x): switch d: case 0: return x case _: return (gen(d-1, x * 2 + 1), gen(d-1, x * 2)) def sum(d, t): switch d: case 0: return t case _: (t.a, t.b) = t return sum(d-1, t.a) + sum(d-1, t.b) def swap(s, a, b): switch s: case 0: return (a,b) case _: return (b,a) def warp(d, s, a, b): switch d: case 0: return swap(s ^ (a > b), a, b) case _: (a.a,a.b) = a (b.a,b.b) = b (A.a,A.b) = warp(d-1, s, a.a, b.a) (B.a,B.b) = warp(d-1, s, a.b, b.b) return ((A.a,B.a),(A.b,B.b)) def flow(d, s, t): switch d: case 0: return t case _: (t.a, t.b) = t return down(d, s, warp(d-1, s, t.a, t.b)) def down(d,s,t): switch d: case 0: return t case _: (t.a, t.b) = t return (flow(d-1, s, t.a), flow(d-1, s, t.b)) def sort(d, s, t): switch d: case 0: return t case _: (t.a, t.b) = t return flow(d, s, (sort(d-1, 0, t.a), sort(d-1, 1, t.b))) def main: # In the guide it's 18 return sum(10, sort(10, 0, gen(10, 0))) ================================================ FILE: tests/golden_tests/run_file/guide_circle_area.bend ================================================ type Shape: Circle { radius } Rectangle { width, height } def area(shape): match shape: case Shape/Circle: return 3.14 * shape.radius ** 2.0 case Shape/Rectangle: return shape.width * shape.height def main: return area(Shape/Circle { radius: 10.0 }) ================================================ FILE: tests/golden_tests/run_file/guide_distance_4args.bend ================================================ def distance(ax, ay, bx, by): dx = bx - ax dy = by - ay return (dx * dx + dy * dy) ** 0.5 def main(): return distance(10.0, 10.0, 20.0, 20.0) ================================================ FILE: tests/golden_tests/run_file/guide_distance_obj.bend ================================================ object V2 { x, y } def distance(a, b): open V2: a open V2: b dx = b.x - a.x dy = b.y - a.y return (dx * dx + dy * dy) ** 0.5 def main(): return distance(V2 { x: 10.0, y: 10.0 }, V2 { x: 20.0, y: 20.0 }) ================================================ FILE: tests/golden_tests/run_file/guide_distance_tup.bend ================================================ def distance(a, b): (ax, ay) = a (bx, by) = b dx = bx - ax dy = by - ay return (dx * dx + dy * dy) ** 0.5 def main(): return distance((10.0, 10.0), (20.0, 20.0)) ================================================ FILE: tests/golden_tests/run_file/guide_enumerate.bend ================================================ def enum(tree): idx = 0 fold tree with idx: case Tree/Node: return ![tree.left(idx * 2 + 0), tree.right(idx * 2 + 1)] case Tree/Leaf: return !(idx, tree.value) def main: tree = ![![!1, !2], ![!3, !4]] return enum(tree) ================================================ FILE: tests/golden_tests/run_file/guide_if_age.bend ================================================ def am_i_old(age): if age < 18: return "you're a kid" else: return "you're an adult" def main(): return am_i_old(32) ================================================ FILE: tests/golden_tests/run_file/guide_is_even_num.bend ================================================ def is_even(n): if n % 2 == 0: return 1 else: return 0 def main: return is_even(7) ================================================ FILE: tests/golden_tests/run_file/guide_is_even_str.bend ================================================ def is_even(x): if x % 2 == 0: return "even" else: return "odd" def main: return is_even(7) ================================================ FILE: tests/golden_tests/run_file/guide_list_ctrs.bend ================================================ def main: my_list = List/Cons { head: 1, tail: List/Cons { head: 2, tail: List/Cons { head: 3, tail: List/Nil }}} return my_list ================================================ FILE: tests/golden_tests/run_file/guide_list_match.bend ================================================ def main: my_list = [1, 2, 3] match my_list: case List/Cons: return my_list.head case List/Nil: return 0 ================================================ FILE: tests/golden_tests/run_file/guide_list_sugar.bend ================================================ def main: my_list = [1, 2, 3] return my_list ================================================ FILE: tests/golden_tests/run_file/guide_mul2_inline.bend ================================================ def main: mul_2 = lambda x: x * 2 return mul_2(7) ================================================ FILE: tests/golden_tests/run_file/guide_mul2_rec.bend ================================================ def slow_mul2(n): switch n: case 0: return 0 case _: return 2 + slow_mul2(n-1) def main: return slow_mul2(7) ================================================ FILE: tests/golden_tests/run_file/guide_shader_dummy.bend ================================================ # given a shader, returns a square image def render(depth): bend d = 0, i = 0: when d < depth: color = (fork(d+1, i*2+0), fork(d+1, i*2+1)) else: width = depth / 2 color = demo_shader(i % width, i / width) return color # given a position, returns a color # for this demo, it just busy loops def demo_shader(x, y): bend i = 0: when i < 10: color = fork(i + 1) else: color = 0x000001 return color # renders a 256x256 image using demo_shader def main: return render(5) ================================================ FILE: tests/golden_tests/run_file/guide_sum.bend ================================================ def sum(tree): fold tree: case Tree/Node: return tree.left + tree.right case Tree/Leaf: return tree.value def main: tree = ![![!1, !2], ![!3, !4]] return sum(tree) ================================================ FILE: tests/golden_tests/run_file/hvm_def_cast.bend ================================================ # Expected +42.0 hvm to_f24_: ($([f24] a) a) main = (to_f24_ 42) ================================================ FILE: tests/golden_tests/run_file/hvm_def_two_defs.bend ================================================ # Expected result: -0.349 hvm log_: (x ($([|] $(x ret)) ret)) hvm atan2_: ($([&] $(y ret)) (y ret)) main = (log_ (atan2_ 1.0 1.0) 2.0) ================================================ FILE: tests/golden_tests/run_file/id_underscore.bend ================================================ id _ = _ main = (id {2, 3}) ================================================ FILE: tests/golden_tests/run_file/imp_empty_literals.bend ================================================ def list: return [] def map: return {} def str: return "" def main: return [] ================================================ FILE: tests/golden_tests/run_file/imp_use_statement.bend ================================================ def bar(x, y): return {x, y} def main(x): use result = bar(1, x) return {result, result} ================================================ FILE: tests/golden_tests/run_file/kind_compiled_tree_sum.bend ================================================ #WARNING: unsolved metas. #WARNING: unsolved metas. _Char = 0 _List = λ_T 0 _List.cons = λ_head λ_tail λ_P λ_cons λ_nil ((_cons _head) _tail) _List.nil = λ_P λ_cons λ_nil _nil _Nat = 0 _Nat.succ = λ_n λ_P λ_succ λ_zero (_succ _n) _Nat.zero = λ_P λ_succ λ_zero _zero _String = (_List _Char) _String.cons = λ_head λ_tail λ_P λ_cons λ_nil ((_cons _head) _tail) _String.nil = λ_P λ_cons λ_nil _nil _Tree = λ_A 0 _Tree.fold = λ_bm λ_nd λ_lf let _bm.P = 0; let _bm.node = λ_bm.val λ_bm.lft λ_bm.rgt λ_nd λ_lf (((_nd _bm.val) (((_Tree.fold _bm.lft) _nd) _lf)) (((_Tree.fold _bm.rgt) _nd) _lf)); let _bm.leaf = λ_nd λ_lf _lf; ((((let _bm = _bm (_bm _bm.P) _bm.node) _bm.leaf) _nd) _lf) _Tree.gen = λ_n λ_x switch _n = _n { 0: _Tree.leaf _: let _n-1 = _n-1 ( _Tree.node _x (_Tree.gen _n-1 (+ (* _x 2) 1)) (_Tree.gen _n-1 (+ (* _x 2) 2)) ) } _Tree.leaf = λ_P λ_node λ_leaf _leaf _Tree.node = λ_val λ_lft λ_rgt λ_P λ_node λ_leaf (((_node _val) _lft) _rgt) _Tree.sum = λ_x let _x.P = 0 let _x.node = λ_x.val λ_x.lft λ_x.rgt (+ _x.val (+ _x.lft _x.rgt)) let _x.leaf = 0 ((let _x = _x (_Tree.fold _x) _x.node) _x.leaf) main = (_Tree.sum ((_Tree.gen 16) 0)) ================================================ FILE: tests/golden_tests/run_file/lam_op2.bend ================================================ main = λx (+ x 2) ================================================ FILE: tests/golden_tests/run_file/lam_op2_nested.bend ================================================ main = λx (+ (* x x) (+ (+ 2 x) 3)) ================================================ FILE: tests/golden_tests/run_file/let_tup_readback.bend ================================================ main = λa let (x1, x2) = a; (x1 x2) ================================================ FILE: tests/golden_tests/run_file/linearize_match.bend ================================================ main = @a @b let c = (+ a a); switch a { 0: b; _: (+ a-1 b); } ================================================ FILE: tests/golden_tests/run_file/list_resugar.bend ================================================ Main = (List/Cons 42 (List/Cons (List/Cons @x x List/Nil) List/Nil)) ================================================ FILE: tests/golden_tests/run_file/list_reverse.bend ================================================ type list = (cons h t) | nil reverse (list/cons h t) = (concat (reverse t) (list/cons h list/nil)) reverse list/nil = list/nil concat (list/cons h t) x = (list/cons h (concat t x)) concat list/nil x = x main = (reverse (list/cons 3 (list/cons 2 (list/cons 1 list/nil)))) ================================================ FILE: tests/golden_tests/run_file/list_reverse_imp.bend ================================================ def reverse(list): fold list with acc = []: case List/Nil: return acc case List/Cons: return list.tail(List/Cons(list.head, acc)) def main: bend n = 5: when n != 0: xs = List/Cons(n, fork(n - 1)) else: xs = List/Nil return reverse(xs) ================================================ FILE: tests/golden_tests/run_file/list_take.bend ================================================ Take_ n list = switch _ = (== n 0) { | 0: (Take n list) | _: [] } Take n (List/Nil) = [] Take n (List/Cons x xs) = (List/Cons x (Take_ (- n 1) xs)) main = (Take 2 [3, 2, 1, 5, 5, 5]) ================================================ FILE: tests/golden_tests/run_file/list_to_tree.bend ================================================ List/len list = (List/len/go list 0) List/len/go [] count = count List/len/go (List/Cons x xs) count = (List/len/go xs (+ count 1)) Take/go n list = switch _ = (== n 0) { | 0: (Take n list) | _: [] } Take n [] = [] Take n (List/Cons x xs) = (List/Cons x (Take/go (- n 1) xs)) Drop/go n list = switch _ = (== n 0) { | 0: (Drop n list) | _: list } Drop n [] = [] Drop n (List/Cons x xs) = (Drop/go (- n 1) xs) List/toTree [] = * List/toTree [x] = x List/toTree xs = let half = (/ (List/len xs) 2); let x = (Take half xs); let y = (Drop half xs); {(List/toTree x), (List/toTree y)} Main = (List/toTree [1, 2, 3, 4, 5]) ================================================ FILE: tests/golden_tests/run_file/mapper_syntax.bend ================================================ def main: x = 1 x @= lambda x: x + 1 map = { 0: 3, 1: 4 } map[1] += 1 map[1] @= lambda x: x * 2 return (x, map[1], map[0]) ================================================ FILE: tests/golden_tests/run_file/match.bend ================================================ main = switch _ = (+ 0 1) { 0: λt λf t _: λt λf f } ================================================ FILE: tests/golden_tests/run_file/match_builtins.bend ================================================ Bar [(String/Cons x xs), y] = {xs, y} Bar * = [] Main = (Bar ["hello", "world"]) ================================================ FILE: tests/golden_tests/run_file/match_mult_linearization.bend ================================================ main = @a @b @c @d switch a { 0: (+ (+ b c) d); _: (+ (+ (+ a-1 b) c) d); } ================================================ FILE: tests/golden_tests/run_file/match_num_adt_tup_parser.bend ================================================ # Testing various forms of pattern matching type Result_ = (Ok val) | (Err err) Parse state (String/Cons '{' xs) = (Result_/Ok ('{', xs, state)) Parse state (String/Cons '}' xs) = (Result_/Ok ('}', xs, state)) Parse state (String/Cons '\n' xs) = (Result_/Ok (0, xs, state)) Parse state xs = (Result_/Err {xs, state}) main = let str = "(+"; let state = *; match res = (Parse state str) { Result_/Ok: let (val, xs, state) = res.val; {val, (Parse state xs)} err: err } ================================================ FILE: tests/golden_tests/run_file/match_num_explicit_bind.bend ================================================ pred = @n switch n { 0: 0 _: n-1 } main = (pred 4) ================================================ FILE: tests/golden_tests/run_file/match_num_num_to_char.bend ================================================ num_to_char n = switch n { 0: '0' 1: '1' 2: '2' 3: '3' 4: '4' 5: '5' 6: '6' 7: '7' 8: '8' 9: '9' _: '\0' } char_to_num '9' = 9 char_to_num '8' = 8 char_to_num '7' = 7 char_to_num '6' = 6 char_to_num '5' = 5 char_to_num '4' = 4 char_to_num '3' = 3 char_to_num '2' = 2 char_to_num '1' = 1 char_to_num '0' = 0 char_to_num _ = (- 0 1) map f List/Nil = List/Nil map f (List/Cons x xs) = (List/Cons (f x) (map f xs)) main = let nums = [0 1 2 3 4 5 6 7 8 9 10]; let chars = (map num_to_char nums); let nums2 = (map char_to_num chars); {{nums, nums2}, chars} ================================================ FILE: tests/golden_tests/run_file/match_num_succ_complex.bend ================================================ min1 * 0 = 0 min1 0 * = 0 min1 a b = (+ 1 (min1 (- a 1) (- b 1))) min2 a b = switch a { 0: 0 _: switch b { 0: 0 _: (+ 1 (min2 a-1 b-1)) } } map f xs = match xs { List/Cons: (List/Cons (f xs.head) (map f xs.tail)) List/Nil: List/Nil } vals = [(5, 10) (10, 5) (0, 12) (12 0) (0 0) (6 6)] main = let f1 = @x let (a, b) = x; (min1 a b) let f2 = @x let (a, b) = x; (min2 a b) let a = [f1 f2] (map @a (map a vals) a) ================================================ FILE: tests/golden_tests/run_file/match_str.bend ================================================ (is_as "As") = 2 (is_as "as") = 2 (is_as "") = 1 (is_as *) = 0 map f (List/Cons x xs) = (List/Cons (f x) (map f xs)) map f [] = [] main = (map is_as ["As" "as" "" "Asd" "qwerty" "AAs"]) ================================================ FILE: tests/golden_tests/run_file/match_sup.bend ================================================ main = let k = #a{0 1}; switch k { 0: 1 _: (+ k-1 2) } ================================================ FILE: tests/golden_tests/run_file/match_vars.bend ================================================ main = match 0 { | true: 1 | false: 0 } ================================================ FILE: tests/golden_tests/run_file/math.bend ================================================ def main: use rad = Math/radians return [ Math/sin(rad(30.0)), Math/cos(rad(30.0)), Math/tan(rad(30.0)), Math/cot(rad(30.0)), Math/sec(rad(30.0)), Math/csc(rad(30.0)), Math/asin(rad(30.0)), Math/acos(rad(30.0)), Math/atan(rad(30.0)), rad(67.4), rad(45.0), rad(90.0), Math/sqrt(9.0), Math/ceil(9.75), Math/floor(9.75), Math/ceil(-8.75), Math/floor(-8.75), Math/ceil(1.0), Math/floor(1.0), Math/ceil(0.0), Math/floor(0.0), Math/round(5.6), Math/round(5.5), Math/round(5.4), ] ================================================ FILE: tests/golden_tests/run_file/merge_sort.bend ================================================ sort (Tree/Leaf v) = (List/Cons v List/Nil) sort (Tree/Node a b) = (merge (sort a) (sort b)) merge (List/Nil) b = b merge (List/Cons x xs) (List/Nil) = (List/Cons x xs) merge (List/Cons x xs) (List/Cons y ys) = let t = switch _ = (< x y) { 0: λaλbλcλt(t c a b) _: λaλbλcλt(t a b c) } let t = (t (List/Cons x) λx(x) (List/Cons y)) (t λa λb λc (a (merge (b xs) (c ys)))) sum List/Nil = 0 sum (List/Cons h t) = (+ h (sum t)) range n = switch n { 0: λx (Tree/Leaf x) _: λx (Tree/Node (range n-1 (+ (* x 2) 1)) (range n-1 (* x 2))) } main = (sum (sort (range 4 0))) ================================================ FILE: tests/golden_tests/run_file/mixed_syntax.bend ================================================ type Bool: True False type MyTree = (node ~lft ~rgt) | (leaf val) def tree_xor(tree): fold tree: case MyTree/node: return xor(tree.lft, tree.rgt); case MyTree/leaf: return tree.val; (xor Bool/True Bool/False) = Bool/True (xor Bool/False Bool/True) = Bool/True (xor * *) = Bool/False main = let depth = 10 let tree = bend n = 0 { when (< n depth): (MyTree/node (fork (+ n 1)) (fork (+ n 1))) else: if (% n 2) { (MyTree/leaf Bool/True) } else { (MyTree/leaf Bool/False) } } (tree_xor tree) ================================================ FILE: tests/golden_tests/run_file/names_hyphen.bend ================================================ id cool-var-name = cool-var-name type Done_ = (Done done-var) toZero n = switch n { 0: (Done_/Done 1) _: (toZero n-1) } main = match is-done = (toZero 4) { Done_/Done: is-done.done-var } ================================================ FILE: tests/golden_tests/run_file/names_hyphen_toplevel.bend ================================================ type Foo-Bar = (Baz-Qux field-hyph) fun-with-hyphen = 1 main = @x (x (Foo-Bar/Baz-Qux 1) fun-with-hyphen) ================================================ FILE: tests/golden_tests/run_file/nat_add.bend ================================================ (Nat/add (Nat/Zero) x) = x (Nat/add (Nat/Succ p) x) = (Nat/Succ (Nat/add p x)) (Main) = (Nat/add #25 #9) ================================================ FILE: tests/golden_tests/run_file/nat_add_num.bend ================================================ (Nat/add (Nat/Zero) x) = x (Nat/add (Nat/Succ p) x) = (Nat/Succ (Nat/add p x)) main = (Nat/add #4 0) ================================================ FILE: tests/golden_tests/run_file/nested_list_and_string.bend ================================================ main = @a [ a, (*, 2), (String/Cons [7, "1234", 9] (String/Cons a (String/Cons * (String/Cons '4' (String/Cons '2' String/Nil))))) ] ================================================ FILE: tests/golden_tests/run_file/nested_map_get.bend ================================================ def x: return { 0: 1, 1: 42, 2: 0, 3: 2 } def main(): return x[x[0]] + x[x[x[3]]] ================================================ FILE: tests/golden_tests/run_file/nested_map_set.bend ================================================ def main(): map = { 0: 1, 1: 10, 2: 0, 3: 1, 4: 3 } map[map[0]] = 99 map[map[2]] = 1 return map[map[map[4]]] + map[map[2]] ================================================ FILE: tests/golden_tests/run_file/nested_str.bend ================================================ Main = ( (String/Cons "a" String/Nil), (String/Cons 'a' (String/Cons "bc" String/Nil)), (String/Cons "ab" (String/Cons 'c' String/Nil)), (String/Cons "ab" (String/Cons "cd" String/Nil)) ) ================================================ FILE: tests/golden_tests/run_file/num_cast.bend ================================================ main: _ = use inf = (** 9.0 (** 9.0 9.0)) ( (i24/to_u24 -1), (i24/to_u24 +1), (i24/to_u24 +0), (i24/to_u24 +400), (f24/to_u24 1.0), (f24/to_u24 1.5), (f24/to_u24 -3.0), (f24/to_u24 -3.5), (f24/to_u24 inf), # inf (f24/to_u24 (* -1.0 inf)), # -inf (f24/to_u24 (/ inf inf)), # nan (inf/inf) 99999, (u24/to_i24 0), (u24/to_i24 1), (u24/to_i24 123456), (f24/to_i24 1.0), (f24/to_i24 1.5), (f24/to_i24 -3.0), (f24/to_i24 -3.5), (f24/to_i24 inf), # inf (f24/to_i24 (* -1.0 inf)), # -inf (f24/to_i24 (/ inf inf)), # nan (inf/inf) 99999, (u24/to_f24 0), (u24/to_f24 1), (u24/to_f24 123456), (i24/to_f24 -1), (i24/to_f24 +1), (i24/to_f24 +0), (i24/to_f24 +400) ) ================================================ FILE: tests/golden_tests/run_file/num_match_missing_var.bend ================================================ if 0 t f = f if 1 t f = t if2 n t f = switch n { 0: f _: t _: f } if3 n t f = switch n { 0: f _: t 1: t } main = (if2 1 2 3) ================================================ FILE: tests/golden_tests/run_file/num_pred.bend ================================================ Pred n = switch n { 0: 0 _: n-1 } Main = (Pred 43) ================================================ FILE: tests/golden_tests/run_file/open.bend ================================================ type Pair = (new a b) type State: new { a, b } def with_state(x, s): open State: s return Pair/new(s, x(s.a)) main = let x = (with_state @x x (State/new 1 2)) open Pair x; {x.a x.b} ================================================ FILE: tests/golden_tests/run_file/open_object.bend ================================================ object Pair { fst, snd } def main: x = Pair(1, 2) open Pair: x return x.fst ================================================ FILE: tests/golden_tests/run_file/open_too_many_ctrs.bend ================================================ type MyTree: node { a, b } leaf { a } def main: x = MyTree/node(1, 2) open MyTree: x return x.a ================================================ FILE: tests/golden_tests/run_file/open_undefined_type.bend ================================================ def main: x = 1 open MyType: x return x.a ================================================ FILE: tests/golden_tests/run_file/ops.bend ================================================ def main: return [ 1 + 2 == 3, 2 - 1 == 1, -5 + -1 == -6, -3 * -9 == +27, 0.250 + 0.125 == 0.375, 1 >= 1 == 1, 1 <= 0 == 0, 42 >= 43 == 0, ] ================================================ FILE: tests/golden_tests/run_file/override_list_ctr.bend ================================================ List/Nil = * main = [λz λk z] ================================================ FILE: tests/golden_tests/run_file/override_str_ctr.bend ================================================ String/Cons = * main = (String/Cons "any") ================================================ FILE: tests/golden_tests/run_file/pred.bend ================================================ Pred = λt switch t { 0: 0 _: t-1 } main = (Pred 3) ================================================ FILE: tests/golden_tests/run_file/queue.bend ================================================ # A cool trick involving HVM's scopeless lambdas is linear qs: # Qnew : Queue a Qnew = λx x # Qadd : a -> Queue a -> Queue a Qadd = λx λq λk (q λc (c x k)) # Qrem : Queue a -> Pair a (Queue a) Qrem = λq (q $k λx λxs λp(p x λ$k xs)) Nil = λc λn n Cons = λh λt λc λn (c h t) # Output: [1, 2, 3] main = let q = Qnew let q = ((Qadd) 1 q) let q = ((Qadd) 2 q) let q = ((Qadd) 3 q) (((Qrem) q) λv0 λq (((Qrem) q) λv1 λq (((Qrem) q) λv2 λq ((Cons) 1 ((Cons) 2 ((Cons) 3 Nil)))))) ================================================ FILE: tests/golden_tests/run_file/radix_sort_ctr.bend ================================================ type Map_ = Free | Used | (Both a b) type Arr = Null | (Leaf x) | (Node a b) (Swap s a b) = switch s { 0: (Map_/Both a b) _: (Map_/Both b a) } # Sort : Arr -> Arr (Sort t) = (ToArr 0 (ToMap t)) # ToMap : Arr -> Map (ToMap Arr/Null) = Map_/Free (ToMap (Arr/Leaf a)) = (Radix a) (ToMap (Arr/Node a b)) = (Merge (ToMap a) (ToMap b)) # ToArr : U60 -> Map -> Arr (ToArr x Map_/Free) = Arr/Null (ToArr x Map_/Used) = (Arr/Leaf x) (ToArr x (Map_/Both a b)) = let a = (ToArr (+ (* x 2) 0) a) let b = (ToArr (+ (* x 2) 1) b) (Arr/Node a b) # Merge : Map -> Map -> Map (Merge Map_/Free Map_/Free) = Map_/Free (Merge Map_/Free Map_/Used) = Map_/Used (Merge Map_/Used Map_/Free) = Map_/Used (Merge Map_/Used Map_/Used) = Map_/Used (Merge Map_/Free (Map_/Both c d)) = (Map_/Both c d) (Merge (Map_/Both a b) Map_/Free) = (Map_/Both a b) (Merge (Map_/Both a b) (Map_/Both c d)) = (Map_/Both (Merge a c) (Merge b d)) (Merge (Map_/Both a b) Map_/Used) = * (Merge Map_/Used (Map_/Both a b)) = * # Radix : U60 -> Map (Radix n) = let r = Map_/Used let r = (Swap (& n 1) r Map_/Free) let r = (Swap (& n 2) r Map_/Free) let r = (Swap (& n 4) r Map_/Free) let r = (Swap (& n 8) r Map_/Free) let r = (Swap (& n 16) r Map_/Free) (Radix2 n r) (Radix2 n r) = let r = (Swap (& n 32) r Map_/Free) let r = (Swap (& n 64) r Map_/Free) let r = (Swap (& n 128) r Map_/Free) let r = (Swap (& n 256) r Map_/Free) let r = (Swap (& n 512) r Map_/Free) (Radix3 n r) (Radix3 n r) = let r = (Swap (& n 1024) r Map_/Free) let r = (Swap (& n 2048) r Map_/Free) let r = (Swap (& n 4096) r Map_/Free) let r = (Swap (& n 8192) r Map_/Free) let r = (Swap (& n 16384) r Map_/Free) (Radix4 n r) (Radix4 n r) = let r = (Swap (& n 32768) r Map_/Free) let r = (Swap (& n 65536) r Map_/Free) let r = (Swap (& n 131072) r Map_/Free) let r = (Swap (& n 262144) r Map_/Free) let r = (Swap (& n 524288) r Map_/Free) (Radix5 n r) (Radix5 n r) = let r = (Swap (& n 1048576) r Map_/Free) let r = (Swap (& n 2097152) r Map_/Free) let r = (Swap (& n 4194304) r Map_/Free) let r = (Swap (& n 8388608) r Map_/Free) r # Reverse : Arr -> Arr (Reverse Arr/Null) = Arr/Null (Reverse (Arr/Leaf a)) = (Arr/Leaf a) (Reverse (Arr/Node a b)) = (Arr/Node (Reverse b) (Reverse a)) # Sum : Arr -> U60 (Sum Arr/Null) = 0 (Sum (Arr/Leaf x)) = x (Sum (Arr/Node a b)) = (+ (Sum a) (Sum b)) # Gen : U60 -> Arr (Gen n) = (Gen.go n 0) (Gen.go n x) = switch n { 0: (Arr/Leaf x) _: let a = (* x 2) let b = (| (* x 2) 1) (Arr/Node (Gen.go n-1 a) (Gen.go n-1 b)) } Main = (Sum (Sort (Reverse (Gen 4)))) ================================================ FILE: tests/golden_tests/run_file/readback_hvm1_main.bend ================================================ Main = λa Main ================================================ FILE: tests/golden_tests/run_file/readback_list_other_ctr.bend ================================================ # Check that the ctr in the middle are interpreted correctly type tup = (pair a b) main = (List/Cons (String/Cons 'a' (tup/pair 'b' (String/Cons 'c' String/Nil))) (List/Cons 1 (tup/pair 2 (List/Cons 3 (List/Cons 4 List/Nil)))) ) ================================================ FILE: tests/golden_tests/run_file/readback_num_ops.bend ================================================ main = [ @a (+ a 1), @a (+ 1 a), @a @b (+ a b), @a (- a 1), @a (- 1 a), @a @b @c (+ a (- b c)) @a @b @c (+ (- a b) c) ] ================================================ FILE: tests/golden_tests/run_file/recursive_bind.bend ================================================ Result/bind (Result/Ok val) f = ((undefer f) val) Result/bind err _ = err Bar x = (Result/Err 0) Foo x y = with Result { ask x = (Bar x); (Foo x y) } Main = (Foo "a" 0) ================================================ FILE: tests/golden_tests/run_file/recursive_combinator.bend ================================================ # Tests that `(Foo 0)` is correctly extracted as a combinator, otherwise the file would hang when running Foo = @x (x (Foo 0) @y (Foo y)) main = (Foo 0) ================================================ FILE: tests/golden_tests/run_file/recursive_combinator_nested.bend ================================================ # Tests that `({Foo @* a} 9)` is correctly extracted as a combinator, otherwise the file would hang when running Foo = @a switch a { 0: (#a {Foo @* a} 9); _: a-1 } main = (Foo 0) ================================================ FILE: tests/golden_tests/run_file/recursive_match_native.bend ================================================ add = λa λb (+ a b) sum = λn switch n { 0: 1 _: (add (sum n-1) (sum n-1)) } main = (sum 9) ================================================ FILE: tests/golden_tests/run_file/ref_resolution.bend ================================================ x = 0 id x = x main = (id 42) ================================================ FILE: tests/golden_tests/run_file/repeated_name_truncation.bend ================================================ long_name_that_truncates = @a @b long_name_that_truncates2 long_name_that_truncates2 = 2 long_name_that_truncates_too = @a a main = (long_name_that_truncates long_name_that_truncates_too) ================================================ FILE: tests/golden_tests/run_file/scopeless_discard.bend ================================================ main = let * = λ$x 1 {2, $x} ================================================ FILE: tests/golden_tests/run_file/str_concat.bend ================================================ concat (String/Nil) str = str concat (String/Cons c rest1) str2 = (String/Cons c (concat rest1 str2)) main = (concat "hello " "world") ================================================ FILE: tests/golden_tests/run_file/str_inc.bend ================================================ (StrInc (len, buf)) = (len, #str λx (StrGo len #str (buf x))) (StrGo 0 str) = str (StrGo x (head, tail)) = ((+ 1 head), (StrGo (- x 1) tail)) # Old str encoding Hello = (11, #str λx (104, (101, (108, (108, (111, (32, (119, (111, (114, (108, (100, x)))))))))))) main = (StrInc Hello) ================================================ FILE: tests/golden_tests/run_file/str_inc_eta.bend ================================================ (StrInc (len, buf)) = (len, #str λx (StrGo len #str (buf x))) (StrGo 0 (head, tail)) = (head, tail) (StrGo x (head, tail)) = ((+ 1 head), (StrGo (- x 1) tail)) # Old str encoding Hello = (11, #str λx (104, (101, (108, (108, (111, (32, (119, (111, (114, (108, (100, x)))))))))))) main = (StrInc Hello) ================================================ FILE: tests/golden_tests/run_file/str_len.bend ================================================ String/len s = (String/len/go s 0) String/len/go (String/Nil) x = x String/len/go (String/Cons hd tl) x = (String/len/go tl (+ x 1)) main = (String/len "λx 🐼") ================================================ FILE: tests/golden_tests/run_file/strict_monad_fn.bend ================================================ # This will only work if we make the call to `(Result/foo a b)` lazy (by converting it to a combinator). Result/bind = @val @nxt match val { Result/Ok: ((undefer nxt) val.val) Result/Err: (Result/Err val.val) } Result/foo x y = with Result { ask a = (Result/Ok x) ask b = switch y { 0: (Result/Err a); _: (Result/Ok y-1) } (Result/foo a b) } main = (Result/foo 1 2) ================================================ FILE: tests/golden_tests/run_file/sum_tree.bend ================================================ add = λa λb (+ a b) gen = λn switch n { 0: (Tree/Leaf 1) _: (Tree/Node (gen n-1) (gen n-1)) } sum = λt match t { Tree/Leaf: t.value Tree/Node: (add (sum t.left) (sum t.right)) } main = (sum (gen 8)) ================================================ FILE: tests/golden_tests/run_file/sup_app.bend ================================================ main = ({(λx x) (λx x)} 3) ================================================ FILE: tests/golden_tests/run_file/sup_reconstruction.bend ================================================ main = λa let {b c} = a; {b c} ================================================ FILE: tests/golden_tests/run_file/superposed_is_even.bend ================================================ type MyNat = (S pred) | Z type MyBool = T | F (Not MyBool/T) = MyBool/F (Not MyBool/F) = MyBool/T (IsEven n) = match n { MyNat/S: (Not (IsEven n.pred)) MyNat/Z: MyBool/T } N0 = MyNat/Z N1 = (MyNat/S N0) N2 = (MyNat/S N1) N3 = (MyNat/S N2) Main = (IsEven {{N0 N1} {N2 N3}}) ================================================ FILE: tests/golden_tests/run_file/tagged_lam.bend ================================================ main = #foo ((#foo @x (+ x 1), #foo @x (* x x)) 2) ================================================ FILE: tests/golden_tests/run_file/tree_to_list.bend ================================================ def main: var = Tree/reverse(![![!1, !2],![!3, !4]]) return Tree/to_list(var) ================================================ FILE: tests/golden_tests/run_file/tup_list_strings.bend ================================================ Main = {[{"foo", 0}, {"foo", 0}, {"foo", 1}], 4} ================================================ FILE: tests/golden_tests/run_file/tup_reconstruction.bend ================================================ main = λa let (b, c) = a; (b, c) ================================================ FILE: tests/golden_tests/run_file/tuple_eta.bend ================================================ main = (10.0, 10.0) ================================================ FILE: tests/golden_tests/run_file/tuple_rots.bend ================================================ MkTup8 = @a @b @c @d @e @f @g @h @MkTup8 (MkTup8 a b c d e f g h) rot = λx (x λa λb λc λd λe λf λg λh (MkTup8 b c d e f g h a)) app = λn switch n { 0: λf λx x _: λf λx (app n-1 f (f x)) } main = (app 100 rot (MkTup8 1 2 3 4 5 6 7 8)) ================================================ FILE: tests/golden_tests/run_file/unaplied_str.bend ================================================ main = λa λb (String/Cons a (String/Cons 'b' (String/Cons 'c' (String/Cons b String/Nil)))) ================================================ FILE: tests/golden_tests/run_file/unbound_wrap.bend ================================================ type Maybe_ = (Some x) | None Maybe_/bind val nxt = match val { Maybe_/Some: (nxt val.x) Maybe_/None: Maybe_/None } main = with Maybe_ { (wrap 1) } ================================================ FILE: tests/golden_tests/run_file/unscoped_never_used.bend ================================================ type Bool = T | F main = @x match x { Bool/T : @$x * Bool/F : @x * } ================================================ FILE: tests/golden_tests/run_file/unused_dup_var.bend ================================================ X = λx x # This leaves (b1 X) with an ERA in the return, but the DUP is kept with an unused var main = ( (λa λb let {b1 b2} = b; (a (b1 X) (b2 X))) (λa λb b) ) ================================================ FILE: tests/golden_tests/run_file/unused_main_var.bend ================================================ # Despite having an unused variable in main, `map(tt,l)` should not be extracted into a new definition. def map(fn, list): fold list: case List/Cons: return List/Cons(fn(list.head), list.tail) case List/Nil: return [] def tt(x): return x*2 def main(): l = [5,6,7,8] k = [1,2,3,4] return map(tt,l) ================================================ FILE: tests/golden_tests/run_file/world.bend ================================================ main = (String/Cons '\u{1F30E}' String/Nil) ================================================ FILE: tests/golden_tests/run_file/wrong_string.bend ================================================ Main = (String/Cons (*, 4) (String/Cons * String/Nil)) ================================================ FILE: tests/golden_tests/run_lazy/addition.bend ================================================ (main) = (λx (+ (+ 1 1) x) 8) ================================================ FILE: tests/golden_tests/run_lazy/adt_match.bend ================================================ data Opt = (Some x) | None Opt/map = @opt @f match opt { Opt/Some: (Opt/Some (f opt.x)); Opt/None: Opt/None } inc = @x (+ x 1) main = let opt = (Opt/Some 1); (Opt/map opt inc) ================================================ FILE: tests/golden_tests/run_lazy/adt_match_wrong_tag.bend ================================================ data Option = (Some val) | None main = λa #Option (a #wrong_tag λb b *) ================================================ FILE: tests/golden_tests/run_lazy/adt_option_and.bend ================================================ data Option = (Some val) | None Option/and = @a @b match a { Option/Some: match b { Option/Some: (Option/Some (a.val, b.val)) Option/None: Option/None } Option/None: Option/None } main = Option/and ================================================ FILE: tests/golden_tests/run_lazy/adt_wrong_tag.bend ================================================ data Option = (Some val) | None main = (@a #Option (a #wrong_tag @x x *)) ================================================ FILE: tests/golden_tests/run_lazy/and.bend ================================================ data bool = true | false and a bool/false = bool/false and a bool/true = a main = (and bool/true bool/false) ================================================ FILE: tests/golden_tests/run_lazy/bitonic_sort.bend ================================================ data Tree = (Leaf a) | (Both a b) data Error = Err # Atomic Swapper (Swap n a b) = switch n { 0: (Tree/Both a b) _: (Tree/Both b a) } # Swaps distant values in parallel; corresponds to a Red Box (Warp s (Tree/Leaf a) (Tree/Leaf b)) = (Swap (^ (> a b) s) (Tree/Leaf a) (Tree/Leaf b)) (Warp s (Tree/Both a b) (Tree/Both c d)) = (Join (Warp s a c) (Warp s b d)) (Warp s a b) = Error/Err # Rebuilds the warped tree in the original order (Join (Tree/Both a b) (Tree/Both c d)) = (Tree/Both (Tree/Both a c) (Tree/Both b d)) (Join a b) = Error/Err # Recursively warps each sub-tree; corresponds to a Blue/Green Box (Flow s (Tree/Leaf a)) = (Tree/Leaf a) (Flow s (Tree/Both a b)) = (Down s (Warp s a b)) # Propagates Flow downwards (Down s (Tree/Leaf a)) = (Tree/Leaf a) (Down s (Tree/Both a b)) = (Tree/Both (Flow s a) (Flow s b)) # Bitonic Sort (Sort s (Tree/Leaf a)) = (Tree/Leaf a) (Sort s (Tree/Both a b)) = (Flow s (Tree/Both (Sort 0 a) (Sort 1 b))) # Generates a tree of depth `n` (Gen n x) = switch n { 0: (Tree/Leaf x) _: (Tree/Both (Gen n-1 (* x 2)) (Gen n-1 (+ (* x 2) 1))) } # Reverses a tree (Rev (Tree/Leaf x)) = (Tree/Leaf x) (Rev (Tree/Both a b)) = (Tree/Both (Rev b) (Rev a)) # Sums a tree (Sum (Tree/Leaf x)) = x (Sum (Tree/Both a b)) = (+ (Sum a) (Sum b)) Main = (Sum (Sort 0 (Rev (Gen 4 0)))) ================================================ FILE: tests/golden_tests/run_lazy/bitonic_sort_lam.bend ================================================ # data Tree = (Leaf x) | (Node x0 x1) Leaf = λx #Tree λl #Tree λn (l x) Node = λx0 λx1 #Tree λl #Tree λn (n x0 x1) swap = λn switch n { 0: λx0 λx1 (Node x0 x1) _: λx0 λx1 (Node x1 x0) } warp = λa let a_leaf = λax λb let b_leaf = λbx λax λs (swap (^ (> ax bx) s) (Leaf ax) (Leaf bx)) let b_node = λa0 λa1 λax λs 0 (#Tree (b b_leaf b_node) ax) let a_node = λa0 λa1 λb let b_leaf = λbx λa0 λa1 λs 0 let b_node = λb0 λb1 λa0 λa1 λs (join (warp a0 b0 s) (warp a1 b1 s)) (#Tree (b b_leaf b_node) a0 a1) #Tree (a a_leaf a_node) join = λa let a_leaf = λax λb 0 let a_node = λa0 λa1 λb let b_leaf = λbx λa0 λa1 0 let b_node = λb0 λb1 λa0 λa1 (Node (Node a0 b0) (Node a1 b1)) (#Tree (b b_leaf b_node) a0 a1) #Tree (a a_leaf a_node) flow = λa let a_leaf = λax λs (Leaf ax) let a_node = λa0 λa1 λs (down (warp a0 a1 s) s) #Tree (a a_leaf a_node) down = λa let a_leaf = λax λs (Leaf ax) let a_node = λa0 λa1 λs (Node (flow a0 s) (flow a1 s)) #Tree (a a_leaf a_node) sort = λa let a_leaf = λax λs (Leaf ax) let a_node = λa0 λa1 λs (flow (Node (sort a0 0) (sort a1 1)) s) #Tree (a a_leaf a_node) gen = λn switch n { 0: λx (Leaf x) _: λx (Node (gen n-1 (* x 2)) (gen n-1 (+ (* x 2) 1))) } rev = λa let a_leaf = λax (Leaf ax) let a_node = λa0 λa1 (Node (rev a1) (rev a0)) #Tree (a a_leaf a_node) sum = λa let a_leaf = λax ax let a_node = λa0 λa1 (+ (sum a0) (sum a1)) #Tree (a a_leaf a_node) main = (sum (sort (rev (gen 8 0)) 0)) ================================================ FILE: tests/golden_tests/run_lazy/box.bend ================================================ data _Box = (Box val) Box/subst (_Box/Box n) from to = (Box/subst/go n (== from n) to) Box/subst/go a 0 to = (_Box/Box a) Box/subst/go a * to = to Main = (Box/subst (_Box/Box 4) 4 (_Box/Box 10)) ================================================ FILE: tests/golden_tests/run_lazy/box2.bend ================================================ data _Box = (Box val) Box/subst (_Box/Box n) from to = (Box/subst/go n (== from n) to) Box/subst/go a 0 to = (_Box/Box a) Box/subst/go a * to = to Main = (Box/subst (_Box/Box 4) 8000 (_Box/Box 10)) ================================================ FILE: tests/golden_tests/run_lazy/callcc.bend ================================================ (CC.lang program) = let callcc = λcallback (λ$garbage($hole) (callback λ$hole(0))) let result = (program callcc) let garbage = $garbage result Main = (CC.lang λcallcc (+ 10 (callcc λk(+ (k 42) 1729)))) ================================================ FILE: tests/golden_tests/run_lazy/chars.bend ================================================ main = (String/cons '\u{1234}' (String/cons '!' (String/cons '7' String/nil))) ================================================ FILE: tests/golden_tests/run_lazy/def_tups.bend ================================================ go (a, (b, (c, (d, e)))) = (+ (+ (+ (+ e d) c) b) a) go2 (a, b, c, d, e) = (+ (+ (+ (+ e d) c) b) a) main = ( (go (1, (2, (3, (4, 5))))), (go2 (1, 2, 3, 4, 5)) ) ================================================ FILE: tests/golden_tests/run_lazy/dup_global_lam.bend ================================================ (main) = let {x1 x2} = $a; ((λ$a λb b) (x1 x2)) ================================================ FILE: tests/golden_tests/run_lazy/eta.bend ================================================ Id = λb b main = λa (Id a) ================================================ FILE: tests/golden_tests/run_lazy/example.bend ================================================ # Write definitions like this (Def1) = ((λa a) (λb b)) # You can call a definition by just referencing its name # It will be substituted in place of the reference (Def2) = ((λa a) Def1) # Definitions and variables can have names in upper and lower case and contain numbers # Names defined in a more inner position shadow names in an outer position (def3) = ((λDef1 Def1) (λx λx x)) # The language is affine, but if you use a variable more than once the compiler inserts duplications for you # Of course you can always do them manually (def4) = λz let {z1 z2} = z; (z1 ((λx (x x x x x)) z2)) # You can use machine numbers and some native numeric operations # Numeric operations can only reduce numbers, doing (+ (λx x) 1) will not do anything (nums) = λx1 λx2 (* (+ x1 1) (/ (- x2 2) 1)) # You can use numbers on the native match expression # The `+` arm binds the `scrutinee`-1 variable to the the value of the number -1 (Num.pred) = λn switch n { 0: 0 _: n-1 } # Write new data types like this data Option = (Some val) | None data Bool = True | False # You can have pattern matching on definitions # Use `*` to ignore a pattern (Option.unwrap_or (Option/Some val) *) = val (Option.unwrap_or Option/None or) = or (Bool.or Bool/True *) = Bool/True (Bool.or * Bool/True) = Bool/True (Bool.or * *) = Bool/False # Or using a match expression (Bool.not) = λbool match bool { Bool/True: Bool/False Bool/False: Bool/True } # Data types can store values data Boxed = (Box val) # Types with only one constructor can be destructured using `let` or a single matching definition (Box.map (Boxed/Box val) f) = (Boxed/Box (f val)) (Box.unbox) = λbox match box { Boxed/Box: box.val } # Use tuples to store two values together without needing to create a new data type (Tuple.new fst snd) = let pair = (fst, snd) pair # Then you can destructure it inside the definition or using `let` (Tuple.fst (fst, snd)) = fst (Tuple.snd) = λpair let (fst, snd) = pair snd # All files must have a main definition to be run. # You can execute a program in HVM with "cargo run -- run " # Other options are "check" (the default mode) to just see if the file is well formed # and "compile" to output hvm-core code. (main) = let tup = (Tuple.new None (Num.pred 5)) let fst = (Tuple.fst tup) let snd = (Tuple.snd tup) let box = (Boxed/Box fst) let map = (Box.map box Option.unwrap_or) let unboxed = ((Box.unbox map) snd) (nums 3 unboxed) ================================================ FILE: tests/golden_tests/run_lazy/exp.bend ================================================ main = ((λfλx (f (f x))) (λfλx (f (f x)))) ================================================ FILE: tests/golden_tests/run_lazy/extracted_match_pred.bend ================================================ # We expect the lambda 'p' from the match to be extracted which allows this recursive func val = λn (switch n { 0: valZ; _: (valS n-1) }) valZ = 0 valS = λp (val p) main = (val 1) ================================================ FILE: tests/golden_tests/run_lazy/field_vectorization.bend ================================================ # Vectorizes if the adts are encoded with tagged scott encoding data Box = (New a) data Bool = T | F data List_ = (Cons x xs) | Nil data Pair = (Tup a b) (Tup.and (Pair/Tup (Box/New Bool/T) (Box/New Bool/T))) = Bool/T (Tup.and (Pair/Tup a b)) = Bool/F (Not Bool/T) = Bool/F (Not Bool/F) = Bool/T main = (Not (Tup.and (List_/Cons (Pair/Tup (Box/New Bool/T) (Box/New Bool/F)) (List_/Cons (Pair/Tup (Box/New Bool/F) (Box/New Bool/F)) (List_/Cons (Pair/Tup (Box/New Bool/T) (Box/New Bool/T)) (List_/Cons (Pair/Tup (Box/New Bool/F) (Box/New Bool/T)) List_/Nil ) ) ) ) ) ) ================================================ FILE: tests/golden_tests/run_lazy/lam_op2.bend ================================================ main = λx (+ x 2) ================================================ FILE: tests/golden_tests/run_lazy/lam_op2_nested.bend ================================================ main = λx (+ (* x x) (+ (+ 2 x) 3)) ================================================ FILE: tests/golden_tests/run_lazy/let_tup_readback.bend ================================================ main = λa let (x1, x2) = a; (x1 x2) ================================================ FILE: tests/golden_tests/run_lazy/linearize_match.bend ================================================ main = @a @b let c = (+ a a); switch a { 0: b; _: (+ a-1 b); } ================================================ FILE: tests/golden_tests/run_lazy/list_resugar.bend ================================================ Main = (List/cons 42 (List/cons (List/cons @x x List/nil) List/nil)) ================================================ FILE: tests/golden_tests/run_lazy/list_reverse.bend ================================================ data list = (cons h t) | nil reverse (list/cons h t) = (concat (reverse t) (list/cons h list/nil)) reverse list/nil = list/nil concat (list/cons h t) x = (list/cons h (concat t x)) concat list/nil x = x main = (reverse (list/cons 3 (list/cons 2 (list/cons 1 list/nil)))) ================================================ FILE: tests/golden_tests/run_lazy/list_take.bend ================================================ Take_ n list = switch _ = (== n 0) { | 0: (Take n list) | _: [] } Take n (List/nil) = [] Take n (List/cons x xs) = (List/cons x (Take_ (- n 1) xs)) main = (Take 2 [3, 2, 1, 5, 5, 5]) ================================================ FILE: tests/golden_tests/run_lazy/list_to_tree.bend ================================================ List/len list = (List/len/go list 0) List/len/go [] count = count List/len/go (List/cons x xs) count = (List/len/go xs (+ count 1)) Take/go n list = switch _ = (== n 0) { | 0: (Take n list) | _: [] } Take n [] = [] Take n (List/cons x xs) = (List/cons x (Take/go (- n 1) xs)) Drop/go n list = switch _ = (== n 0) { | 0: (Drop n list) | _: list } Drop n [] = [] Drop n (List/cons x xs) = (Drop/go (- n 1) xs) List/toTree [] = * List/toTree [x] = x List/toTree xs = let half = (/ (List/len xs) 2); let x = (Take half xs); let y = (Drop half xs); {(List/toTree x), (List/toTree y)} Main = (List/toTree [1, 2, 3, 4, 5]) ================================================ FILE: tests/golden_tests/run_lazy/match.bend ================================================ main = switch _ = (+ 0 1) { 0: λt λf t _: λt λf f } ================================================ FILE: tests/golden_tests/run_lazy/match_builtins.bend ================================================ Bar [(String/cons x xs), y] = (xs, y) Bar * = [] Main = (Bar ["hello", "world"]) ================================================ FILE: tests/golden_tests/run_lazy/match_mult_linearization.bend ================================================ main = @a @b @c @d switch a { 0: (+ (+ b c) d); _: (+ (+ (+ a-1 b) c) d); } ================================================ FILE: tests/golden_tests/run_lazy/match_num_explicit_bind.bend ================================================ pred = @n switch n { 0: 0 _: n-1 } main = (pred 4) ================================================ FILE: tests/golden_tests/run_lazy/merge_sort.bend ================================================ data Tree = (Leaf x) | (Node x0 x1) data List_ = Nil | (Cons h t) sort (Tree/Leaf v) = (List_/Cons v List_/Nil) sort (Tree/Node a b) = (merge (sort a) (sort b)) merge (List_/Nil) b = b merge (List_/Cons x xs) (List_/Nil) = (List_/Cons x xs) merge (List_/Cons x xs) (List_/Cons y ys) = let t = switch _ = (< x y) { 0: λaλbλcλt(t c a b) _: λaλbλcλt(t a b c) } let t = (t (List_/Cons x) λx(x) (List_/Cons y)) (t λa λb λc (a (merge (b xs) (c ys)))) sum List_/Nil = 0 sum (List_/Cons h t) = (+ h (sum t)) range n = switch n { 0: λx (Tree/Leaf x) _: λx (Tree/Node (range n-1 (+ (* x 2) 1)) (range n-1 (* x 2))) } main = (sum (sort (range 4 0))) ================================================ FILE: tests/golden_tests/run_lazy/nested_list_and_string.bend ================================================ main = @a [ a, (*, 2), (String/cons [7, "1234", 9] (String/cons a (String/cons * (String/cons '4' (String/cons '2' String/nil))))) ] ================================================ FILE: tests/golden_tests/run_lazy/nested_str.bend ================================================ Main = ( (String/cons "a" String/nil), (String/cons 'a' (String/cons "bc" String/nil)), (String/cons "ab" (String/cons 'c' String/nil)), (String/cons "ab" (String/cons "cd" String/nil)) ) ================================================ FILE: tests/golden_tests/run_lazy/num_pred.bend ================================================ Pred n = switch n { 0: 0 _: n-1 } Main = (Pred 43) ================================================ FILE: tests/golden_tests/run_lazy/queue.bend ================================================ # A cool trick involving HVM's scopeless lambdas is linear qs: # Qnew : Queue a Qnew = λx x # Qadd : a -> Queue a -> Queue a Qadd = λx λq λk (q λc (c x k)) # Qrem : Queue a -> Pair a (Queue a) Qrem = λq (q $k λx λxs λp(p x λ$k xs)) Nil = λc λn n Cons = λh λt λc λn (c h t) # Output: [1, 2, 3] main = let q = Qnew let q = ((Qadd) 1 q) let q = ((Qadd) 2 q) let q = ((Qadd) 3 q) (((Qrem) q) λv0 λq (((Qrem) q) λv1 λq (((Qrem) q) λv2 λq ((Cons) 1 ((Cons) 2 ((Cons) 3 Nil)))))) ================================================ FILE: tests/golden_tests/run_lazy/radix_sort_ctr.bend ================================================ data Map_ = Free | Used | (Both a b) data Arr = Null | (Leaf x) | (Node a b) (Swap s a b) = switch s { 0: (Map_/Both a b) _: (Map_/Both b a) } # Sort : Arr -> Arr (Sort t) = (ToArr 0 (ToMap t)) # ToMap : Arr -> Map (ToMap Arr/Null) = Map_/Free (ToMap (Arr/Leaf a)) = (Radix a) (ToMap (Arr/Node a b)) = (Merge (ToMap a) (ToMap b)) # ToArr : U60 -> Map -> Arr (ToArr x Map_/Free) = Arr/Null (ToArr x Map_/Used) = (Arr/Leaf x) (ToArr x (Map_/Both a b)) = let a = (ToArr (+ (* x 2) 0) a) let b = (ToArr (+ (* x 2) 1) b) (Arr/Node a b) # Merge : Map -> Map -> Map (Merge Map_/Free Map_/Free) = Map_/Free (Merge Map_/Free Map_/Used) = Map_/Used (Merge Map_/Used Map_/Free) = Map_/Used (Merge Map_/Used Map_/Used) = Map_/Used (Merge Map_/Free (Map_/Both c d)) = (Map_/Both c d) (Merge (Map_/Both a b) Map_/Free) = (Map_/Both a b) (Merge (Map_/Both a b) (Map_/Both c d)) = (Map_/Both (Merge a c) (Merge b d)) (Merge (Map_/Both a b) Map_/Used) = * (Merge Map_/Used (Map_/Both a b)) = * # Radix : U60 -> Map (Radix n) = let r = Map_/Used let r = (Swap (& n 1) r Map_/Free) let r = (Swap (& n 2) r Map_/Free) let r = (Swap (& n 4) r Map_/Free) let r = (Swap (& n 8) r Map_/Free) let r = (Swap (& n 16) r Map_/Free) (Radix2 n r) (Radix2 n r) = let r = (Swap (& n 32) r Map_/Free) let r = (Swap (& n 64) r Map_/Free) let r = (Swap (& n 128) r Map_/Free) let r = (Swap (& n 256) r Map_/Free) let r = (Swap (& n 512) r Map_/Free) (Radix3 n r) (Radix3 n r) = let r = (Swap (& n 1024) r Map_/Free) let r = (Swap (& n 2048) r Map_/Free) let r = (Swap (& n 4096) r Map_/Free) let r = (Swap (& n 8192) r Map_/Free) let r = (Swap (& n 16384) r Map_/Free) (Radix4 n r) (Radix4 n r) = let r = (Swap (& n 32768) r Map_/Free) let r = (Swap (& n 65536) r Map_/Free) let r = (Swap (& n 131072) r Map_/Free) let r = (Swap (& n 262144) r Map_/Free) let r = (Swap (& n 524288) r Map_/Free) (Radix5 n r) (Radix5 n r) = let r = (Swap (& n 1048576) r Map_/Free) let r = (Swap (& n 2097152) r Map_/Free) let r = (Swap (& n 4194304) r Map_/Free) let r = (Swap (& n 8388608) r Map_/Free) r # Reverse : Arr -> Arr (Reverse Arr/Null) = Arr/Null (Reverse (Arr/Leaf a)) = (Arr/Leaf a) (Reverse (Arr/Node a b)) = (Arr/Node (Reverse b) (Reverse a)) # Sum : Arr -> U60 (Sum Arr/Null) = 0 (Sum (Arr/Leaf x)) = x (Sum (Arr/Node a b)) = (+ (Sum a) (Sum b)) # Gen : U60 -> Arr (Gen n) = (Gen.go n 0) (Gen.go n x) = switch n { 0: (Arr/Leaf x) _: let a = (* x 2) let b = (| (* x 2) 1) (Arr/Node (Gen.go n-1 a) (Gen.go n-1 b)) } Main = (Sum (Sort (Reverse (Gen 4)))) ================================================ FILE: tests/golden_tests/run_lazy/recursive_match_native.bend ================================================ add = λa λb (+ a b) sum = λn switch n { 0: 1 _: (add (sum n-1) (sum n-1)) } main = (sum 9) ================================================ FILE: tests/golden_tests/run_lazy/scopeless_discard.bend ================================================ main = let * = λ$x 1 (2, $x) ================================================ FILE: tests/golden_tests/run_lazy/str_concat.bend ================================================ concat (String/nil) str = str concat (String/cons c rest1) str2 = (String/cons c (concat rest1 str2)) main = (concat "hello " "world") ================================================ FILE: tests/golden_tests/run_lazy/str_inc.bend ================================================ (StrInc (len, buf)) = (len, #str λx (StrGo len #str (buf x))) (StrGo 0 str) = str (StrGo x (head, tail)) = ((+ 1 head), (StrGo (- x 1) tail)) # Old str encoding Hello = (11, #str λx (104, (101, (108, (108, (111, (32, (119, (111, (114, (108, (100, x)))))))))))) main = (StrInc Hello) ================================================ FILE: tests/golden_tests/run_lazy/str_inc_eta.bend ================================================ (StrInc (len, buf)) = (len, #str λx (StrGo len #str (buf x))) (StrGo 0 (head, tail)) = (head, tail) (StrGo x (head, tail)) = ((+ 1 head), (StrGo (- x 1) tail)) # Old str encoding Hello = (11, #str λx (104, (101, (108, (108, (111, (32, (119, (111, (114, (108, (100, x)))))))))))) main = (StrInc Hello) ================================================ FILE: tests/golden_tests/run_lazy/str_len.bend ================================================ String/len s = (String/len/go s 0) String/len/go (String/nil) x = x String/len/go (String/cons hd tl) x = (String/len/go tl (+ x 1)) main = (String/len "λx 🐼") ================================================ FILE: tests/golden_tests/run_lazy/sum_tree.bend ================================================ data Tree = (Leaf x) | (Node x0 x1) add = λa λb (+ a b) gen = λn switch n { 0: (Tree/Leaf 1) _: (Tree/Node (gen n-1) (gen n-1)) } sum = λt match t { Tree/Leaf: t.x Tree/Node: (add (sum t.x0) (sum t.x1)) } main = (sum (gen 8)) ================================================ FILE: tests/golden_tests/run_lazy/sup_app.bend ================================================ main = (#id {(λx x) (λx x)} 3) ================================================ FILE: tests/golden_tests/run_lazy/sup_reconstruction.bend ================================================ main = λa let #s {b c} = a; #s {b c} ================================================ FILE: tests/golden_tests/run_lazy/superposed_is_even.bend ================================================ data N = (S pred) | Z data B = T | F (Not B/T) = B/F (Not B/F) = B/T (IsEven n) = match n { N/S: (Not (IsEven n.pred)) N/Z: B/T } N0 = N/Z N1 = (N/S N0) N2 = (N/S N1) N3 = (N/S N2) Main = (IsEven {{N0 N1} {N2 N3}}) ================================================ FILE: tests/golden_tests/run_lazy/tagged_lam.bend ================================================ main = #foo ((#foo @x (+ x 1), #foo @x (* x x)) 2) ================================================ FILE: tests/golden_tests/run_lazy/tup_reconstruction.bend ================================================ main = λa let (b, c) = a; (b, c) ================================================ FILE: tests/golden_tests/run_lazy/tuple_rots.bend ================================================ MkTup8 = @a @b @c @d @e @f @g @h @MkTup8 (MkTup8 a b c d e f g h) rot = λx (x λa λb λc λd λe λf λg λh (MkTup8 b c d e f g h a)) app = λn switch n { 0: λf λx x _: λf λx (app n-1 f (f x)) } main = (app 100 rot (MkTup8 1 2 3 4 5 6 7 8)) ================================================ FILE: tests/golden_tests/run_lazy/unaplied_str.bend ================================================ main = λa λb (String/cons a (String/cons 'b' (String/cons 'c' (String/cons b String/nil)))) ================================================ FILE: tests/golden_tests/run_lazy/unused_dup_var.bend ================================================ X = λx x # This leaves (b1 X) with an ERA in the return, but the DUP is kept with an unused var main = ( (λa λb let {b1 b2} = b; (a (b1 X) (b2 X))) (λa λb b) ) ================================================ FILE: tests/golden_tests/run_lazy/world.bend ================================================ main = (String/cons '\u{1F30E}' String/nil) ================================================ FILE: tests/golden_tests/run_lazy/wrong_string.bend ================================================ Main = (String/cons (*, 4) (String/cons * String/nil)) ================================================ FILE: tests/golden_tests/scott_triggers_unused/test.bend ================================================ # The test below should not trigger this warning: # # In definition 'f': # Definition is unused. # In definition 't': # Definition is unused. # # This was happening because the prune algorithm was just collecting constructors # by searching for tags. type bool = t | f main = @b match b { bool/t: 0; bool/f: 1} ================================================ FILE: tests/golden_tests/simplify_matches/adt_tup_era.bend ================================================ type Tuple = (Pair a b) (Foo (Tuple/Pair (Tuple/Pair a b) c)) = a (Foo *) = 2 Main = (Foo (Tuple/Pair 1 5)) ================================================ FILE: tests/golden_tests/simplify_matches/already_flat.bend ================================================ type Foo = CtrA | (CtrB x) type Bar = (CtrA1 a) | (CtrA2 a1 a2) | (CtrA3 a) type Baz = (CtrB0) | (CtrB1 b) | (CtrB2 b) | (CtrB3 b) Rule1 = λx x Rule2 a = λx x Rule3 a b c d = (a b c d) Rule4 (Foo/CtrA) = λx x Rule4 (Foo/CtrB x) = x Rule4 x = x Rule5 (Bar/CtrA1 a) b = (a b) Rule5 (Bar/CtrA2 a1 a2) b = (a1 a2 b) Rule5 a (Baz/CtrB0) = a Rule5 a (Baz/CtrB1 b) = (a b) Rule5 (Bar/CtrA3 a) (Baz/CtrB3 b) = (a b) Rule5 a b = (a b) Rule6 a = a Rule6 b = b ================================================ FILE: tests/golden_tests/simplify_matches/bits_dec.bend ================================================ type Data/Bits = e | (o t) | (i t) Data.Bits.dec Data/Bits/e = (Data/Bits/e) Data.Bits.dec (Data/Bits/o (Data/Bits/e)) = (Data/Bits/e) Data.Bits.dec (Data/Bits/i (Data/Bits/e)) = (Data/Bits/o (Data/Bits/e)) Data.Bits.dec (Data/Bits/i (Data/Bits/o b.pred)) = (Data/Bits/o b.pred) Data.Bits.dec (Data/Bits/i (Data/Bits/i b.pred)) = (Data/Bits/o b.pred) Data.Bits.dec (Data/Bits/o (Data/Bits/o b.pred)) = (Data/Bits/i (Data.Bits.dec b.pred)) Data.Bits.dec (Data/Bits/o (Data/Bits/i b.pred)) = (Data/Bits/i (Data.Bits.dec b.pred)) ================================================ FILE: tests/golden_tests/simplify_matches/complex_with_case.bend ================================================ type Tree_ = (Node lt rt rd ld) | (Leaf val) (map) = λarg1 λarg2 use tree = arg2; use f = arg1; match tree with f { Tree_/Node: (Tree_/Node (map f tree.lt) (map f tree.rt) (map f tree.rd) (map f tree.ld)); Tree_/Leaf: (Tree_/Leaf (f tree.val)); } main = map ================================================ FILE: tests/golden_tests/simplify_matches/double_unwrap_box.bend ================================================ # Should notice that the second rule is redundant, not create flattened rule for it and not forward the second argument. type Boxed = (Box x) (DoubleUnbox (Boxed/Box (Boxed/Box x)) *) = x (DoubleUnbox * x) = x Main = (DoubleUnbox (Boxed/Box (Boxed/Box 0)) 5) ================================================ FILE: tests/golden_tests/simplify_matches/double_unwrap_maybe.bend ================================================ # We want to make sure that the default value is not mistakenly erased in the first level of flattening. type Maybe_ = (Some x) | None (DoubleUnwrap (Maybe_/Some (Maybe_/Some x)) *) = x (DoubleUnwrap * x) = x Main = (DoubleUnwrap (Maybe_/Some Maybe_/None) 5) ================================================ FILE: tests/golden_tests/simplify_matches/flatten_with_terminal.bend ================================================ # The flattened rule should only have 1 arg, for matching 'B' type A_t = (A b) type B_t = B (Foo 0 (A_t/A B_t/B)) = B_t/B (Foo * *) = * main = (Foo 2 (A_t/A B_t/B)) ================================================ FILE: tests/golden_tests/simplify_matches/irrefutable_case.bend ================================================ l = 1001 v1 = match l { x: x } v2 = match l { x: l } v3 = match [] { x: 2002 } v4 = match l = 3003 { x: x y: 0 } v5 = match p = 4004 with b = 5005 { x: b } main = (v1, v2, v3, v4, v5) ================================================ FILE: tests/golden_tests/simplify_matches/linearize_match_all.bend ================================================ # Testing linearization in different situations type ConsList = (Cons h t) | Nil # Auto linearized on strict mode A = @a @b @c switch a { 0: (b c) _: (a-1 b c) } # Manually linearized B = @a @b @c switch c with a b { 0: (a b) _: (a b c-1) } # Not linearized C = @a @b @c switch c { 0: (a b) _: (a b c-1) } # Auto linearized, one arg not used D = @a @b @c switch a { 0: c _: (a-1 c) } # Pattern matching defs linearize all arguments E (ConsList/Cons a b) (ConsList/Cons c d) = (a b c d) E a b = (a b) A2 = @a @b @c match a { ConsList/Cons: (a.h a.t b c) ConsList/Nil: (b c) } B2 = @a @b @c match c with a b { ConsList/Cons: (a b c.h c.t) ConsList/Nil: (a b) } C2 = @a @b @c match c { ConsList/Cons: (a b c.h c.t) ConsList/Nil: (a b) } D2 = @a @b @c match a { ConsList/Cons: (a.h a.t b c) ConsList/Nil: (b c) } main = * ================================================ FILE: tests/golden_tests/simplify_matches/match_str.bend ================================================ (is_as "As") = 2 (is_as "as") = 2 (is_as "") = 1 (is_as *) = 0 main = * ================================================ FILE: tests/golden_tests/simplify_matches/nested.bend ================================================ type Foo = (CtrA a b) | (CtrB a) type Bar = (CtrB1 b) | (CtrB2 a b) type Baz = CtrC (Rule (Foo/CtrA a (Bar/CtrB1 b))) = (a b) (Rule (Foo/CtrA a (Bar/CtrB2 (Baz/CtrC) b))) = (a b) (Rule (Foo/CtrA a b)) = (a b) (Rule (Foo/CtrB b)) = b (Rule x) = x ================================================ FILE: tests/golden_tests/simplify_matches/nested2.bend ================================================ Foo a (List/Cons b (List/Cons c d)) = (a b c d) Foo a b = (a b) ================================================ FILE: tests/golden_tests/simplify_matches/nested_0ary.bend ================================================ type list = (Cons head tail) | Nil Unpack cmp list/Nil = list/Nil Unpack cmp (list/Cons h list/Nil) = h Unpack cmp xs = (cmp xs) ================================================ FILE: tests/golden_tests/simplify_matches/redundant_with_era.bend ================================================ # Should not create flattened rules for the 2 bottom rules and should properly erase the first arg. (Fn2 * (*, (*, a))) = a (Fn2 0 *) = 0 (Fn2 a *) = (- a 1) main = * ================================================ FILE: tests/golden_tests/simplify_matches/wrong_fn_arity.bend ================================================ (Foo a b c) = 0 (Foo) = 1 ================================================ FILE: tests/golden_tests.rs ================================================ //! This module runs snapshot tests for compiling and running Bend programs. //! //! The result of each test is saved as a snapshot and used as golden output //! for future tests. This allows us to test regressions in compilation and //! have a history of how certain programs compiled and ran. //! //! These tests use `cargo-insta`. To run the tests, run `cargo insta test`. //! If there are any changes to the snapshots, they'll be highlighted by the //! CLI tool. Then, run `cargo insta review` to review these changes. use bend::{ check_book, compile_book, desugar_book, diagnostics::{Diagnostics, DiagnosticsConfig, Severity}, fun::{ load_book::do_parse_book, net_to_term::net_to_term, parser::ParseBook, term_to_net::Labels, Book, Ctx, Name, }, hvm::hvm_book_show_pretty, imports::DefaultLoader, load_to_book, net::hvm_to_net::hvm_to_net, run_book, AdtEncoding, CompileOpts, RunOpts, }; use insta::assert_snapshot; use itertools::Itertools; use std::{ collections::HashMap, fmt::Write, io::Read, path::{Path, PathBuf}, }; use stdext::function_name; use walkdir::WalkDir; // Since running a program requires messing with stdout and stderr, // if we run multiple at the same time, their outputs can get mixed. // So we put a mutex to execute only one "run" test at a time. static RUN_MUTEX: std::sync::Mutex<()> = std::sync::Mutex::new(()); const TESTS_PATH: &str = "/tests/golden_tests/"; type RunFn = dyn Fn(&str, &Path) -> Result; pub fn parse_book_single_file(code: &str, origin: &Path) -> Result { do_parse_book(code, origin, ParseBook::builtins())?.to_fun() } fn run_single_golden_test(path: &Path, run: &[&RunFn]) -> Result<(), String> { println!("{}", path.display()); let code = std::fs::read_to_string(path).map_err(|e| e.to_string())?; let file_name = path.to_str().and_then(|path| path.rsplit_once(TESTS_PATH)).unwrap().1; // unfortunately we need to do this let file_path = format!("{}{}", &TESTS_PATH[1..], file_name); let file_path = Path::new(&file_path); let mut results: HashMap<&Path, Vec> = HashMap::new(); for fun in run { let result = fun(&code, file_path).unwrap_or_else(|err| err.to_string()); results.entry(file_path).or_default().push(result); } let results = results.into_values().map(|v| v.join("\n")).collect_vec(); let mut settings = insta::Settings::clone_current(); settings.set_prepend_module_to_snapshot(false); settings.set_omit_expression(true); settings.set_input_file(path); settings.bind(|| { for result in results { assert_snapshot!(file_name, result); } }); Ok(()) } fn run_golden_test_dir(test_name: &str, run: &RunFn) { run_golden_test_dir_multiple(test_name, &[run]) } fn run_golden_test_dir_multiple(test_name: &str, run: &[&RunFn]) { let root = PathBuf::from(format!( "{}{TESTS_PATH}{}", env!("CARGO_MANIFEST_DIR"), test_name.rsplit_once(':').unwrap().1 )); let walker = WalkDir::new(&root).sort_by_file_name().max_depth(1).into_iter().filter_entry(|e| { let path = e.path(); path == root || path.is_dir() || (path.is_file() && path.extension().is_some_and(|x| x == "bend")) }); for entry in walker { let entry = entry.unwrap(); let path = entry.path(); if path.is_file() { eprintln!("Testing {}", path.display()); run_single_golden_test(path, run).unwrap(); } } } /* Snapshot/regression/golden tests Each tests runs all the files in tests/golden_tests/. The test functions decide how exactly to process the test programs and what to save as a snapshot. */ /// Compiles a file with regular compilation options. #[test] fn compile_file() { run_golden_test_dir(function_name!(), &|code, path| { let mut book = parse_book_single_file(code, path)?; let compile_opts = CompileOpts::default(); let diagnostics_cfg = DiagnosticsConfig { unused_definition: Severity::Allow, ..Default::default() }; let res = compile_book(&mut book, compile_opts, diagnostics_cfg, None)?; Ok(format!("{}{}", res.diagnostics, hvm_book_show_pretty(&res.hvm_book))) }) } /// Compiles a file with `-Oall` option. #[test] fn compile_file_o_all() { run_golden_test_dir(function_name!(), &|code, path| { let mut book = parse_book_single_file(code, path)?; let opts = CompileOpts::default().set_all(); let diagnostics_cfg = DiagnosticsConfig { recursion_cycle: Severity::Warning, unused_definition: Severity::Allow, ..Default::default() }; let res = compile_book(&mut book, opts, diagnostics_cfg, None)?; Ok(format!("{}{}", res.diagnostics, hvm_book_show_pretty(&res.hvm_book))) }) } /// Compiles a file with `-Ono-all` option. #[test] fn compile_file_o_no_all() { run_golden_test_dir(function_name!(), &|code, path| { let mut book = parse_book_single_file(code, path)?; let compile_opts = CompileOpts::default().set_no_all(); let diagnostics_cfg = DiagnosticsConfig::default(); let res = compile_book(&mut book, compile_opts, diagnostics_cfg, None)?; Ok(hvm_book_show_pretty(&res.hvm_book).to_string()) }) } /// Runs a file, but with linear readback enabled. #[test] fn linear_readback() { run_golden_test_dir(function_name!(), &|code, path| { let _guard = RUN_MUTEX.lock().unwrap(); let book = parse_book_single_file(code, path)?; let compile_opts = CompileOpts::default().set_all(); let diagnostics_cfg = DiagnosticsConfig::default(); let (term, _, diags) = run_book( book, RunOpts { linear_readback: true, ..Default::default() }, compile_opts, diagnostics_cfg, None, "run", )? .unwrap(); let res = format!("{diags}{term}"); Ok(res) }); } /// Runs a file with regular compilation options, but rejecting all warnings. /// Runs once for each ADT encoding. #[test] fn run_file() { run_golden_test_dir_multiple( function_name!(), &[(&|code, path| { let _guard = RUN_MUTEX.lock().unwrap(); let book = parse_book_single_file(code, path)?; let diagnostics_cfg = DiagnosticsConfig { unused_definition: Severity::Allow, ..DiagnosticsConfig::new(Severity::Error, true) }; let run_opts = RunOpts::default(); let mut res = String::new(); for adt_encoding in [AdtEncoding::NumScott, AdtEncoding::Scott] { let compile_opts = CompileOpts { adt_encoding, ..CompileOpts::default() }; let (term, _, diags) = run_book(book.clone(), run_opts.clone(), compile_opts, diagnostics_cfg, None, "run")?.unwrap(); res.push_str(&format!("{adt_encoding}:\n{diags}{term}\n\n")); } Ok(res) })], ) } /// Runs bend programs, all sharing a common lib to test the import system. #[test] fn import_system() { run_golden_test_dir_multiple( function_name!(), &[(&|code, path| { let _guard = RUN_MUTEX.lock().unwrap(); let diagnostics_cfg = DiagnosticsConfig { unused_definition: Severity::Allow, ..DiagnosticsConfig::new(Severity::Error, true) }; let book = load_to_book(path, code, DefaultLoader::new(path), diagnostics_cfg)?; let run_opts = RunOpts::default(); let mut res = String::new(); let compile_opts = CompileOpts::default(); let (term, _, diags) = run_book(book, run_opts, compile_opts, diagnostics_cfg, None, "run")?.unwrap(); res.push_str(&format!("{diags}{term}\n\n")); Ok(res) })], ) } /// Reads back an HVM net. #[test] fn readback_hvm() { run_golden_test_dir(function_name!(), &|code, _| { let mut p = hvm::ast::CoreParser::new(code); let net = p.parse_net()?; let book = Book::default(); let compat_net = hvm_to_net(&net); let mut diags = Diagnostics::default(); let term = net_to_term(&compat_net, &book, &Labels::default(), false, &mut diags); Ok(format!("{}{}", diags, term)) }) } /// Runs compilation up to fixing, simplifying and linearizing matches. #[test] fn simplify_matches() { run_golden_test_dir(function_name!(), &|code, path| { let diagnostics_cfg = DiagnosticsConfig { unused_definition: Severity::Allow, irrefutable_match: Severity::Warning, unreachable_match: Severity::Warning, ..DiagnosticsConfig::new(Severity::Error, true) }; let mut book = parse_book_single_file(code, path)?; let mut ctx = Ctx::new(&mut book, diagnostics_cfg); ctx.check_shared_names(); ctx.book.encode_adts(AdtEncoding::NumScott); ctx.fix_match_defs()?; ctx.desugar_open()?; ctx.book.encode_builtins(); ctx.resolve_refs()?; ctx.resolve_type_ctrs()?; ctx.desugar_match_defs()?; ctx.fix_match_terms()?; ctx.book.lift_local_defs(); ctx.desugar_bend()?; ctx.desugar_fold()?; ctx.desugar_with_blocks()?; ctx.check_unbound_vars()?; ctx.book.make_var_names_unique(); ctx.book.desugar_use(); ctx.book.linearize_match_binds(); ctx.book.linearize_match_with(); ctx.check_unbound_vars()?; ctx.book.make_var_names_unique(); ctx.book.desugar_use(); ctx.book.make_var_names_unique(); ctx.prune(false); Ok(format!("{}\n{}", ctx.book, ctx.info)) }) } /// Runs compilation up to encoding `match` terms as lambdas. #[test] fn encode_pattern_match() { run_golden_test_dir(function_name!(), &|code, path| { let mut result = String::new(); for adt_encoding in [AdtEncoding::Scott, AdtEncoding::NumScott] { let diagnostics_cfg = DiagnosticsConfig::default(); let mut book = parse_book_single_file(code, path)?; let mut ctx = Ctx::new(&mut book, diagnostics_cfg); ctx.check_shared_names(); ctx.book.encode_adts(adt_encoding); ctx.fix_match_defs()?; ctx.desugar_open()?; ctx.book.encode_builtins(); ctx.resolve_refs()?; ctx.desugar_match_defs()?; ctx.fix_match_terms()?; ctx.book.lift_local_defs(); ctx.desugar_bend()?; ctx.desugar_fold()?; ctx.desugar_with_blocks()?; ctx.check_unbound_vars()?; ctx.book.make_var_names_unique(); ctx.book.desugar_use(); ctx.book.linearize_match_binds(); ctx.book.linearize_match_with(); ctx.book.encode_matches(adt_encoding); ctx.check_unbound_vars()?; ctx.book.make_var_names_unique(); ctx.book.desugar_use(); ctx.book.make_var_names_unique(); ctx.book.linearize_vars(); ctx.prune(false); writeln!(result, "{adt_encoding}\n{}\n", ctx.book).unwrap(); } Ok(result) }) } /// Parses a file, but does not desugar or compile it. #[test] fn parse_file() { run_golden_test_dir(function_name!(), &|code, path| { let mut book = parse_book_single_file(code, path)?; let mut ctx = Ctx::new(&mut book, Default::default()); ctx.set_entrypoint(); ctx.book.encode_adts(AdtEncoding::NumScott); ctx.book.encode_builtins(); ctx.resolve_refs().expect("Resolve refs"); ctx.prune(false); Ok(book.to_string()) }) } /// Runs the check command on a file. #[test] fn check_file() { run_golden_test_dir(function_name!(), &|code, path| { let compile_opts = CompileOpts::default(); let diagnostics_cfg = DiagnosticsConfig { unused_definition: Severity::Allow, ..DiagnosticsConfig::new(Severity::Error, true) }; let mut book = parse_book_single_file(code, path)?; check_book(&mut book, diagnostics_cfg, compile_opts)?; Ok(book.to_string()) }) } /// Runs compilation up to the last term-level pass (`bend desugar` command). #[test] fn desugar_file() { run_golden_test_dir(function_name!(), &|code, path| { let compile_opts = CompileOpts::default(); let diagnostics_cfg = DiagnosticsConfig { unused_definition: Severity::Allow, ..DiagnosticsConfig::new(Severity::Error, true) }; let mut book = parse_book_single_file(code, path)?; desugar_book(&mut book, compile_opts, diagnostics_cfg, None)?; Ok(book.to_string()) }) } /// Runs a file that is expected to hang. #[test] #[ignore = "bug - the subprocess created by run_book leaks"] fn hangs() { let expected_normalization_time = 5; run_golden_test_dir(function_name!(), &move |code, path| { let _guard = RUN_MUTEX.lock().unwrap(); let book = parse_book_single_file(code, path)?; let compile_opts = CompileOpts::default().set_all(); let diagnostics_cfg = DiagnosticsConfig::new(Severity::Allow, false); let thread = std::thread::spawn(move || { run_book(book, RunOpts::default(), compile_opts, diagnostics_cfg, None, "run") }); std::thread::sleep(std::time::Duration::from_secs(expected_normalization_time)); if !thread.is_finished() { Ok("Hangs".into()) } else if let Err(diags) = thread.join().unwrap() { Err(format!("Doesn't hang. (Compilation failed)\n{diags}").into()) } else { Err("Doesn't hang. (Ran to the end)".to_string().into()) } }) } /// Compiles a file with a custom entrypoint. #[test] fn compile_entrypoint() { run_golden_test_dir(function_name!(), &|code, path| { let mut book = parse_book_single_file(code, path)?; book.entrypoint = Some(Name::new("foo")); let diagnostics_cfg = DiagnosticsConfig { ..DiagnosticsConfig::new(Severity::Error, true) }; let res = compile_book(&mut book, CompileOpts::default(), diagnostics_cfg, None)?; Ok(format!("{}{}", res.diagnostics, hvm_book_show_pretty(&res.hvm_book))) }) } /// Runs a file with a custom entrypoint. #[test] #[ignore = "while execution with different entrypoints is not implemented for hvm32"] fn run_entrypoint() { run_golden_test_dir(function_name!(), &|code, path| { let _guard = RUN_MUTEX.lock().unwrap(); let mut book = parse_book_single_file(code, path)?; book.entrypoint = Some(Name::new("foo")); let compile_opts = CompileOpts::default().set_all(); let diagnostics_cfg = DiagnosticsConfig { ..DiagnosticsConfig::new(Severity::Error, true) }; let (term, _, diags) = run_book(book, RunOpts::default(), compile_opts, diagnostics_cfg, None, "run")?.unwrap(); let res = format!("{diags}{term}"); Ok(res) }) } /// Runs a Bend CLI command. #[test] fn cli() { run_golden_test_dir(function_name!(), &|_code, path| { let _guard = RUN_MUTEX.lock().unwrap(); let mut args_path = PathBuf::from(path); assert!(args_path.set_extension("args")); let mut args_buf = String::with_capacity(16); let mut args_file = std::fs::File::open(args_path).expect("File exists"); args_file.read_to_string(&mut args_buf).expect("Read args"); let args = args_buf.lines(); let output = std::process::Command::new(env!("CARGO_BIN_EXE_bend")).args(args).output().expect("Run command"); let res = format!("{}{}", String::from_utf8_lossy(&output.stderr), String::from_utf8_lossy(&output.stdout)); Ok(res) }) } /// Compiles a file to check for mutual recursion. #[test] fn mutual_recursion() { run_golden_test_dir(function_name!(), &|code, path| { let diagnostics_cfg = DiagnosticsConfig { recursion_cycle: Severity::Error, ..DiagnosticsConfig::new(Severity::Allow, true) }; let mut book = parse_book_single_file(code, path)?; let opts = CompileOpts { merge: true, ..CompileOpts::default() }; let res = compile_book(&mut book, opts, diagnostics_cfg, None)?; Ok(format!("{}{}", res.diagnostics, hvm_book_show_pretty(&res.hvm_book))) }) } /// Runs a file that uses IO. #[test] fn io() { run_golden_test_dir(function_name!(), &|code, path| { let _guard = RUN_MUTEX.lock().unwrap(); let book = parse_book_single_file(code, path)?; let compile_opts = CompileOpts::default(); let diagnostics_cfg = DiagnosticsConfig::default(); let (term, _, diags) = run_book(book, RunOpts::default(), compile_opts, diagnostics_cfg, None, "run-c")?.unwrap(); let res = format!("{diags}{term}"); Ok(format!("Strict mode:\n{res}")) }) } /// Runs a file that uses the prelude. #[test] fn prelude() { run_golden_test_dir(function_name!(), &|code, path| { let _guard = RUN_MUTEX.lock().unwrap(); let book = parse_book_single_file(code, path)?; let compile_opts = CompileOpts::default(); let diagnostics_cfg = DiagnosticsConfig::new(Severity::Error, true); let (term, _, diags) = run_book(book, RunOpts::default(), compile_opts, diagnostics_cfg, None, "run-c")?.unwrap(); let res = format!("{diags}{term}"); Ok(format!("Strict mode:\n{res}")) }) } /// Runs all examples in the examples folder. #[test] fn examples() -> Result<(), Diagnostics> { let examples_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("examples"); for entry in WalkDir::new(examples_path) .min_depth(1) .into_iter() .filter_map(|e| e.ok()) .filter(|e| e.path().extension().map_or(false, |ext| ext == "bend")) { let _guard = RUN_MUTEX.lock().unwrap_or_else(|e| e.into_inner()); let path = entry.path(); eprintln!("Testing {}", path.display()); let code = std::fs::read_to_string(path).map_err(|e| e.to_string())?; let book = parse_book_single_file(&code, path).unwrap(); let compile_opts = CompileOpts::default(); let diagnostics_cfg = DiagnosticsConfig::default(); let (term, _, diags) = run_book(book, RunOpts::default(), compile_opts, diagnostics_cfg, None, "run-c")?.unwrap(); let res = format!("{diags}{term}"); let mut settings = insta::Settings::clone_current(); settings.set_prepend_module_to_snapshot(false); settings.set_omit_expression(true); settings.set_input_file(path); settings.bind(|| { assert_snapshot!(format!("examples__{}", path.file_name().unwrap().to_str().unwrap()), res); }); } Ok(()) } /// Test that the Scott encoding correctly triggers unused definition warnings. #[test] fn scott_triggers_unused() { run_golden_test_dir(function_name!(), &|code, path| { let mut book = parse_book_single_file(code, path)?; let opts = CompileOpts::default(); let diagnostics_cfg = DiagnosticsConfig { unused_definition: Severity::Error, ..DiagnosticsConfig::default() }; let res = compile_book(&mut book, opts, diagnostics_cfg, None)?; Ok(format!("{}{}", res.diagnostics, hvm_book_show_pretty(&res.hvm_book))) }) } // TODO: also run the long string file to test the readback /// Compiles a file that is very large and takes a long time to compile. /// Only outputs if compilation worked without errors. #[test] fn compile_long() { run_golden_test_dir(function_name!(), &|code, path| { let mut book = parse_book_single_file(code, path)?; let opts = CompileOpts::default().set_all(); let diagnostics_cfg = DiagnosticsConfig { recursion_cycle: Severity::Warning, unused_definition: Severity::Allow, ..Default::default() }; compile_book(&mut book, opts.clone(), diagnostics_cfg, None)?; Ok("Compiled".to_string()) }) } ================================================ FILE: tests/snapshots/check_file__fail_type_bad_rec_fn_adt.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/check_file/fail_type_bad_rec_fn_adt.bend --- Errors: In λa match a { Box/Box b: (Erase b); }: Can't unify '(Unit -> d)' and '(Box -> d)'. ================================================ FILE: tests/snapshots/check_file__non_exaustive_limit.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/check_file/non_exaustive_limit.bend --- Errors: In tests/golden_tests/check_file/non_exaustive_limit.bend : In definition 'Bar': Non-exhaustive pattern matching rule. Constructor 'Foo/B' of type 'Foo' not covered ================================================ FILE: tests/snapshots/check_file__type_err_match_arm.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/check_file/type_err_match_arm.bend --- Errors: In tests/golden_tests/check_file/type_err_match_arm.bend : In definition 'Test1': In (Nat_/Zero, Nat_/Zero): Can't unify '(Nat_, Nat_)' and '(Unit, Nat_)'. ================================================ FILE: tests/snapshots/cli__compile_all.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/compile_all.bend --- @Pair.get = (a ((@Pair.get__C1 (a b)) b)) @Pair.get__C0 = (a (b ((a (b c)) c))) @Pair.get__C1 = (?((@Pair.get__C0 *) a) a) @Pair/Pair = (a (b ((0 (a (b c))) c))) @main = d & @Pair.get ~ (($([+] $(a b)) (a b)) (c d)) & @Pair/Pair ~ (40 (2 c)) ================================================ FILE: tests/snapshots/cli__compile_inline.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/compile_inline.bend --- @Era = * @Num = 42 @RefToRef = * @main = a & * ~ (42 (* a)) ================================================ FILE: tests/snapshots/cli__compile_no_opts.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/compile_no_opts.bend --- @main = * ================================================ FILE: tests/snapshots/cli__compile_pre_reduce.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/compile_pre_reduce.bend --- error: invalid value 'pre-reduce' for '-O ' [possible values: all, no-all, eta, no-eta, prune, no-prune, linearize-matches, linearize-matches-alt, no-linearize-matches, float-combinators, no-float-combinators, merge, no-merge, inline, no-inline, check-net-size, no-check-net-size, adt-scott, adt-num-scott, type-check, no-type-check] For more information, try '--help'. ================================================ FILE: tests/snapshots/cli__compile_strict_loop.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/compile_strict_loop.bend --- @A = (((?((0 (* (* (a b)))) c) c) d) d) & @A ~ (a b) @List/Cons = (a (b ((@List/Cons/tag (a (b c))) c))) @List/Cons/tag = 1 @List/Nil = ((@List/Nil/tag a) a) @List/Nil/tag = 0 @main = c & @A ~ (b c) & @List/Cons ~ (4 (a b)) & @List/Cons ~ (4 (@List/Nil a)) ================================================ FILE: tests/snapshots/cli__compile_wrong_opt.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/compile_wrong_opt.bend --- error: invalid value 'foo' for '-O ' [possible values: all, no-all, eta, no-eta, prune, no-prune, linearize-matches, linearize-matches-alt, no-linearize-matches, float-combinators, no-float-combinators, merge, no-merge, inline, no-inline, check-net-size, no-check-net-size, adt-scott, adt-num-scott, type-check, no-type-check] tip: a similar value exists: 'float-combinators' For more information, try '--help'. ================================================ FILE: tests/snapshots/cli__custom_hvm_bin.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/custom_hvm_bin.bend --- Result: λa a ================================================ FILE: tests/snapshots/cli__debug_list_map.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/debug_list_map.bend --- error: unexpected argument '-d' found tip: to pass '-d' as a value, use '-- -d' Usage: bend run-c [OPTIONS] [ARGUMENTS]... For more information, try '--help'. ================================================ FILE: tests/snapshots/cli__debug_u60_to_nat.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/debug_u60_to_nat.bend --- error: unexpected argument '-d' found tip: to pass '-d' as a value, use '-- -d' Usage: bend run-c [OPTIONS] [ARGUMENTS]... For more information, try '--help'. ================================================ FILE: tests/snapshots/cli__desugar_bool_scott.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/desugar_bool_scott.bend --- unchecked main: Any (main) = λa λ* a Boolean/True: Boolean (Boolean/True) = λa λ* a Boolean/False: Boolean (Boolean/False) = λ* λa a ================================================ FILE: tests/snapshots/cli__desugar_float_combinators.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/desugar_float_combinators.bend --- unchecked Z: Any (Z) = λ* λa a unchecked S: Any (S) = λa λb let {c d} = b; λe (c (a d e)) unchecked get: Any (get) = λa (a get__C0 0) unchecked main: Any (main) = (get (S (S Z))) unchecked get__C0: _ (get__C0) = λa (+ a 1) ================================================ FILE: tests/snapshots/cli__desugar_linearize_matches.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/desugar_linearize_matches.bend --- unchecked main: Any (main) = λa λb λc (switch a { 0: λd λ* d; _: λ* λ* λe e; } b c) ================================================ FILE: tests/snapshots/cli__desugar_linearize_matches_alt.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/desugar_linearize_matches_alt.bend --- unchecked main: Any (main) = λa switch a { 0: λb b; _: λ* λc c; } ================================================ FILE: tests/snapshots/cli__desugar_merge.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/desugar_merge.bend --- Warnings: In tests/golden_tests/cli/desugar_merge.bend : In definition 'Z': Definition is unused. unchecked F__M_Z: _ (F__M_Z) = λ* λa a unchecked main: Any (main) = λ* λa a ================================================ FILE: tests/snapshots/cli__desugar_pretty.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/desugar_pretty.bend --- Warnings: In tests/golden_tests/cli/desugar_pretty.bend : In definition 'Foo': Definition is unused. (Foo) = λa λb let (c, d) = a; let (e, f) = b; (+ (+ c d) (+ e f)) (main) = λpat%a let (a, b) = pat%a; λpat%b let {c d *} = pat%b; (+ (+ a b) (+ c d)) ================================================ FILE: tests/snapshots/cli__desugar_prune.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/desugar_prune.bend --- unchecked main: Any (main) = * ================================================ FILE: tests/snapshots/cli__gen_hvm_no_eta_by_default.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/gen_hvm_no_eta_by_default.bend --- @main = a & @make_10 ~ (1 a) @make_10 = (a b) & @make_list ~ (10 (a b)) @make_list = (?(((* (a a)) @make_list__C0) (b c)) (b c)) @make_list__C0 = (b ({a c} ((a (d e)) e))) & @make_list ~ (b (c d)) ================================================ FILE: tests/snapshots/cli__input_file_not_found.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/input_file_not_found.bend --- Errors: The file 'tests/golden_tests/missing_dir/input_file_not_found.bend' was not found. ================================================ FILE: tests/snapshots/cli__net_size_too_large.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/net_size_too_large.bend --- @Arr/Leaf = (a ((@Arr/Leaf/tag (a b)) b)) @Arr/Leaf/tag = 1 @Arr/Node = (a (b ((@Arr/Node/tag (a (b c))) c))) @Arr/Node/tag = 2 @Arr/Null = ((@Arr/Null/tag a) a) @Arr/Null/tag = 0 @Gen = (a b) & @Gen.go ~ (a (0 b)) @Gen.go = (?((@Gen.go__C0 @Gen.go__C1) (a b)) (a b)) @Gen.go__C0 = (a b) & @Arr/Leaf ~ (a b) @Gen.go__C1 = ({a d} ({$([*0x0000002] $([|0x0000001] e)) $([*0x0000002] b)} g)) & @Arr/Node ~ (c (f g)) &!@Gen.go ~ (a (b c)) &!@Gen.go ~ (d (e f)) @Map_/Both = (a (b ((@Map_/Both/tag (a (b c))) c))) @Map_/Both/tag = 2 @Map_/Free = ((@Map_/Free/tag a) a) @Map_/Free/tag = 0 @Map_/Used = ((@Map_/Used/tag a) a) @Map_/Used/tag = 1 @Merge = ((@Merge__C13 (a b)) (a b)) @Merge__C0 = (* (a (b c))) & @Map_/Both ~ (a (b c)) @Merge__C1 = (?((@Map_/Used @Merge__C0) a) a) @Merge__C10 = (* (a (b ((@Merge__C8 (a (b c))) c)))) @Merge__C11 = ((@Merge__C2 a) a) @Merge__C12 = (?((@Merge__C9 @Merge__C10) a) a) @Merge__C13 = (?((@Merge__C11 @Merge__C12) a) a) @Merge__C2 = (?((@Map_/Free @Merge__C1) a) a) @Merge__C3 = (?((@Map_/Used (* (* (* *)))) a) a) @Merge__C4 = (?((@Map_/Used @Merge__C3) a) a) @Merge__C5 = (* (b (e (a (d g))))) & @Map_/Both ~ (c (f g)) &!@Merge ~ (a (b c)) &!@Merge ~ (d (e f)) @Merge__C6 = (a (b c)) & @Map_/Both ~ (a (b c)) @Merge__C7 = (?(((* (* *)) @Merge__C5) a) a) @Merge__C8 = (?((@Merge__C6 @Merge__C7) a) a) @Merge__C9 = ((@Merge__C4 a) a) @Radix = ({$([&0x0800000] a) {$([&0x0400000] b) {$([&0x0200000] c) {$([&0x0100000] d) {$([&0x0080000] e) {$([&0x0040000] f) {$([&0x0020000] g) {$([&0x0010000] h) {$([&0x0008000] i) {$([&0x0004000] j) {$([&0x0002000] k) {$([&0x0001000] l) {$([&0x0000800] m) {$([&0x0000400] n) {$([&0x0000200] o) {$([&0x0000100] p) {$([&0x0000080] q) {$([&0x0000040] r) {$([&0x0000020] s) {$([&0x0000010] t) {$([&0x0000008] u) {$([&0x0000004] v) {$([&0x0000002] w) $([&0x0000001] x)}}}}}}}}}}}}}}}}}}}}}}} vb) & @Swap ~ (a (ub (@Map_/Free vb))) & @Swap ~ (b (tb (@Map_/Free ub))) & @Swap ~ (c (sb (@Map_/Free tb))) & @Swap ~ (d (rb (@Map_/Free sb))) & @Swap ~ (e (qb (@Map_/Free rb))) & @Swap ~ (f (pb (@Map_/Free qb))) & @Swap ~ (g (ob (@Map_/Free pb))) & @Swap ~ (h (nb (@Map_/Free ob))) & @Swap ~ (i (mb (@Map_/Free nb))) & @Swap ~ (j (lb (@Map_/Free mb))) & @Swap ~ (k (kb (@Map_/Free lb))) & @Swap ~ (l (jb (@Map_/Free kb))) & @Swap ~ (m (ib (@Map_/Free jb))) & @Swap ~ (n (hb (@Map_/Free ib))) & @Swap ~ (o (gb (@Map_/Free hb))) & @Swap ~ (p (fb (@Map_/Free gb))) & @Swap ~ (q (eb (@Map_/Free fb))) & @Swap ~ (r (db (@Map_/Free eb))) & @Swap ~ (s (cb (@Map_/Free db))) & @Swap ~ (t (bb (@Map_/Free cb))) & @Swap ~ (u (ab (@Map_/Free bb))) & @Swap ~ (v (z (@Map_/Free ab))) & @Swap ~ (w (y (@Map_/Free z))) & @Swap ~ (x (@Map_/Used (@Map_/Free y))) @Reverse = ((@Reverse__C3 a) a) @Reverse__C0 = (a b) & @Arr/Leaf ~ (a b) @Reverse__C1 = (* (c (a e))) & @Arr/Node ~ (b (d e)) &!@Reverse ~ (a b) &!@Reverse ~ (c d) @Reverse__C2 = (?((@Reverse__C0 @Reverse__C1) a) a) @Reverse__C3 = (?((@Arr/Null @Reverse__C2) a) a) @Sort = (a c) & @ToArr ~ (0 (b c)) & @ToMap ~ (a b) @Sum = ((@Sum__C2 a) a) @Sum__C0 = (* (a (b d))) &!@Sum ~ (a $([+] $(c d))) &!@Sum ~ (b c) @Sum__C1 = (?(((a a) @Sum__C0) b) b) @Sum__C2 = (?((0 @Sum__C1) a) a) @Swap = (?((@Swap__C0 @Swap__C1) (a (b c))) (a (b c))) @Swap__C0 = (a (b c)) & @Map_/Both ~ (a (b c)) @Swap__C1 = (* (b (a c))) & @Map_/Both ~ (a (b c)) @ToArr = (a ((@ToArr__C3 (a b)) b)) @ToArr__C0 = (a b) & @Arr/Leaf ~ (a b) @ToArr__C1 = (* (b (e ({$([*0x0000002] $([+0x0000001] d)) $([*0x0000002] $([+0x0000000] a))} g)))) & @Arr/Node ~ (c (f g)) &!@ToArr ~ (a (b c)) &!@ToArr ~ (d (e f)) @ToArr__C2 = (?((@ToArr__C0 @ToArr__C1) a) a) @ToArr__C3 = (?(((* @Arr/Null) @ToArr__C2) a) a) @ToMap = ((@ToMap__C3 a) a) @ToMap__C0 = (a b) & @Radix ~ (a b) @ToMap__C1 = (* (a (c e))) & @Merge ~ (b (d e)) &!@ToMap ~ (a b) &!@ToMap ~ (c d) @ToMap__C2 = (?((@ToMap__C0 @ToMap__C1) a) a) @ToMap__C3 = (?((@Map_/Free @ToMap__C2) a) a) @main = d & @Sum ~ (c d) & @Sort ~ (b c) & @Reverse ~ (a b) & @Gen ~ (4 a) ================================================ FILE: tests/snapshots/cli__no_check_net_size.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/no_check_net_size.bend --- @Arr/Leaf = (a ((@Arr/Leaf/tag (a b)) b)) @Arr/Leaf/tag = 1 @Arr/Node = (a (b ((@Arr/Node/tag (a (b c))) c))) @Arr/Node/tag = 2 @Arr/Null = ((@Arr/Null/tag a) a) @Arr/Null/tag = 0 @Gen = (a b) & @Gen.go ~ (a (0 b)) @Gen.go = (?((@Gen.go__C0 @Gen.go__C1) (a b)) (a b)) @Gen.go__C0 = (a b) & @Arr/Leaf ~ (a b) @Gen.go__C1 = ({a d} ({$([*0x0000002] $([|0x0000001] e)) $([*0x0000002] b)} g)) & @Arr/Node ~ (c (f g)) &!@Gen.go ~ (a (b c)) &!@Gen.go ~ (d (e f)) @Map_/Both = (a (b ((@Map_/Both/tag (a (b c))) c))) @Map_/Both/tag = 2 @Map_/Free = ((@Map_/Free/tag a) a) @Map_/Free/tag = 0 @Map_/Used = ((@Map_/Used/tag a) a) @Map_/Used/tag = 1 @Merge = ((@Merge__C13 (a b)) (a b)) @Merge__C0 = (* (a (b c))) & @Map_/Both ~ (a (b c)) @Merge__C1 = (?((@Map_/Used @Merge__C0) a) a) @Merge__C10 = (* (a (b ((@Merge__C8 (a (b c))) c)))) @Merge__C11 = ((@Merge__C2 a) a) @Merge__C12 = (?((@Merge__C9 @Merge__C10) a) a) @Merge__C13 = (?((@Merge__C11 @Merge__C12) a) a) @Merge__C2 = (?((@Map_/Free @Merge__C1) a) a) @Merge__C3 = (?((@Map_/Used (* (* (* *)))) a) a) @Merge__C4 = (?((@Map_/Used @Merge__C3) a) a) @Merge__C5 = (* (b (e (a (d g))))) & @Map_/Both ~ (c (f g)) &!@Merge ~ (a (b c)) &!@Merge ~ (d (e f)) @Merge__C6 = (a (b c)) & @Map_/Both ~ (a (b c)) @Merge__C7 = (?(((* (* *)) @Merge__C5) a) a) @Merge__C8 = (?((@Merge__C6 @Merge__C7) a) a) @Merge__C9 = ((@Merge__C4 a) a) @Radix = ({$([&0x0800000] a) {$([&0x0400000] b) {$([&0x0200000] c) {$([&0x0100000] d) {$([&0x0080000] e) {$([&0x0040000] f) {$([&0x0020000] g) {$([&0x0010000] h) {$([&0x0008000] i) {$([&0x0004000] j) {$([&0x0002000] k) {$([&0x0001000] l) {$([&0x0000800] m) {$([&0x0000400] n) {$([&0x0000200] o) {$([&0x0000100] p) {$([&0x0000080] q) {$([&0x0000040] r) {$([&0x0000020] s) {$([&0x0000010] t) {$([&0x0000008] u) {$([&0x0000004] v) {$([&0x0000002] w) $([&0x0000001] x)}}}}}}}}}}}}}}}}}}}}}}} vb) & @Swap ~ (a (ub (@Map_/Free vb))) & @Swap ~ (b (tb (@Map_/Free ub))) & @Swap ~ (c (sb (@Map_/Free tb))) & @Swap ~ (d (rb (@Map_/Free sb))) & @Swap ~ (e (qb (@Map_/Free rb))) & @Swap ~ (f (pb (@Map_/Free qb))) & @Swap ~ (g (ob (@Map_/Free pb))) & @Swap ~ (h (nb (@Map_/Free ob))) & @Swap ~ (i (mb (@Map_/Free nb))) & @Swap ~ (j (lb (@Map_/Free mb))) & @Swap ~ (k (kb (@Map_/Free lb))) & @Swap ~ (l (jb (@Map_/Free kb))) & @Swap ~ (m (ib (@Map_/Free jb))) & @Swap ~ (n (hb (@Map_/Free ib))) & @Swap ~ (o (gb (@Map_/Free hb))) & @Swap ~ (p (fb (@Map_/Free gb))) & @Swap ~ (q (eb (@Map_/Free fb))) & @Swap ~ (r (db (@Map_/Free eb))) & @Swap ~ (s (cb (@Map_/Free db))) & @Swap ~ (t (bb (@Map_/Free cb))) & @Swap ~ (u (ab (@Map_/Free bb))) & @Swap ~ (v (z (@Map_/Free ab))) & @Swap ~ (w (y (@Map_/Free z))) & @Swap ~ (x (@Map_/Used (@Map_/Free y))) @Reverse = ((@Reverse__C3 a) a) @Reverse__C0 = (a b) & @Arr/Leaf ~ (a b) @Reverse__C1 = (* (c (a e))) & @Arr/Node ~ (b (d e)) &!@Reverse ~ (a b) &!@Reverse ~ (c d) @Reverse__C2 = (?((@Reverse__C0 @Reverse__C1) a) a) @Reverse__C3 = (?((@Arr/Null @Reverse__C2) a) a) @Sort = (a c) & @ToArr ~ (0 (b c)) & @ToMap ~ (a b) @Sum = ((@Sum__C2 a) a) @Sum__C0 = (* (a (b d))) &!@Sum ~ (a $([+] $(c d))) &!@Sum ~ (b c) @Sum__C1 = (?(((a a) @Sum__C0) b) b) @Sum__C2 = (?((0 @Sum__C1) a) a) @Swap = (?((@Swap__C0 @Swap__C1) (a (b c))) (a (b c))) @Swap__C0 = (a (b c)) & @Map_/Both ~ (a (b c)) @Swap__C1 = (* (b (a c))) & @Map_/Both ~ (a (b c)) @ToArr = (a ((@ToArr__C3 (a b)) b)) @ToArr__C0 = (a b) & @Arr/Leaf ~ (a b) @ToArr__C1 = (* (b (e ({$([*0x0000002] $([+0x0000001] d)) $([*0x0000002] $([+0x0000000] a))} g)))) & @Arr/Node ~ (c (f g)) &!@ToArr ~ (a (b c)) &!@ToArr ~ (d (e f)) @ToArr__C2 = (?((@ToArr__C0 @ToArr__C1) a) a) @ToArr__C3 = (?(((* @Arr/Null) @ToArr__C2) a) a) @ToMap = ((@ToMap__C3 a) a) @ToMap__C0 = (a b) & @Radix ~ (a b) @ToMap__C1 = (* (a (c e))) & @Merge ~ (b (d e)) &!@ToMap ~ (a b) &!@ToMap ~ (c d) @ToMap__C2 = (?((@ToMap__C0 @ToMap__C1) a) a) @ToMap__C3 = (?((@Map_/Free @ToMap__C2) a) a) @main = d & @Sum ~ (c d) & @Sort ~ (b c) & @Reverse ~ (a b) & @Gen ~ (4 a) ================================================ FILE: tests/snapshots/cli__run_add.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/run_add.bend --- Result: 9 ================================================ FILE: tests/snapshots/cli__run_pretty.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/run_pretty.bend --- Result: λa switch a = a { 0: λb switch b = b { 0: "ba"; _: "ta"; }; _: λ* "ata"; } ================================================ FILE: tests/snapshots/cli__tuple_readback.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/tuple_readback.bend --- Warning: Running in strict mode without enabling the float_combinators pass can lead to some functions expanding infinitely. Result: (λa (1, a), ((1, 2), (λ* 2, (λb λc *, (λd (2, λe $f), λg λh λi $j))))) ================================================ FILE: tests/snapshots/cli__warn_and_err.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/cli/warn_and_err.bend --- Warnings: In tests/golden_tests/cli/warn_and_err.bend : In definition 'Foo': Repeated bind in pattern matching rule: 'a'. Errors: In tests/golden_tests/cli/warn_and_err.bend : In definition 'Main': Unbound variable 'a'. ================================================ FILE: tests/snapshots/compile_entrypoint__foo.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_entrypoint/foo.bend --- @bar = (a a) @foo = a & @bar ~ (2 a) ================================================ FILE: tests/snapshots/compile_file__360_no_scope.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/360_no_scope.bend --- Errors: In tests/golden_tests/compile_file/360_no_scope.bend : - expected: '=' - detected: end of input  6 |   ================================================ FILE: tests/snapshots/compile_file__add_args.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/add_args.bend --- @add = ($([+] $(a b)) (a b)) @main = a & @add ~ a ================================================ FILE: tests/snapshots/compile_file__addition.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/addition.bend --- @main = c & (a b) ~ (8 c) & $(1 $([+] $(a b))) ~ [+0x0000001] ================================================ FILE: tests/snapshots/compile_file__addition_const.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/addition_const.bend --- @main = a & $(2 a) ~ [+0x0000001] ================================================ FILE: tests/snapshots/compile_file__ask_outside_do.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/ask_outside_do.bend --- Errors: In tests/golden_tests/compile_file/ask_outside_do.bend : In definition 'main': Monadic bind operation 'x <- ...' used outside of a `do` block. ================================================ FILE: tests/snapshots/compile_file__church_one.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/church_one.bend --- @main = f & ((a (b c)) ({(c d) a} (b d))) ~ ((* (e e)) f) ================================================ FILE: tests/snapshots/compile_file__church_zero.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/church_zero.bend --- @main = (* (a a)) ================================================ FILE: tests/snapshots/compile_file__complicated_dup.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/complicated_dup.bend --- @main = ({(a b) (d e)} f) & ((c {a d}) b) ~ ((c e) f) ================================================ FILE: tests/snapshots/compile_file__crlf.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/crlf.bend --- @a = 1 @main = 2 ================================================ FILE: tests/snapshots/compile_file__cyclic_global_lam.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/cyclic_global_lam.bend --- Errors: In compiled inet 'main': Found term that compiles into an inet with a vicious cycle ================================================ FILE: tests/snapshots/compile_file__def_pat_unscoped.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/def_pat_unscoped.bend --- @add = ($([+] $(a b)) (a b)) @main = a & @add ~ (9 (4 a)) ================================================ FILE: tests/snapshots/compile_file__dup_apply.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/dup_apply.bend --- @main = ({(a b) a} b) ================================================ FILE: tests/snapshots/compile_file__dup_global_lam.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/dup_global_lam.bend --- @main = d & ({(b c) b} (a a)) ~ (c d) ================================================ FILE: tests/snapshots/compile_file__elif.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/elif.bend --- @main = j & $(2 ?(((?(((?(((?((0 (* 4)) a) a) (* (* 3))) b) b) (* (* (* 2)))) d) d) (* (* (* (* 1))))) (g (h (i j))))) ~ [=0x0000001] & $(1 g) ~ [<0x0000002] & $(2 h) ~ [>0x0000003] & $(2 i) ~ [=0x0000002] ================================================ FILE: tests/snapshots/compile_file__elif_fun.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/elif_fun.bend --- @main = j & $(2 ?(((?(((?(((?((0 (* 4)) a) a) (* (* 3))) b) b) (* (* (* 2)))) d) d) (* (* (* (* 1))))) (g (h (i j))))) ~ [=0x0000001] & $(1 g) ~ [<0x0000002] & $(2 h) ~ [>0x0000003] & $(2 i) ~ [=0x0000002] ================================================ FILE: tests/snapshots/compile_file__elif_no_else.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/elif_no_else.bend --- Errors: In tests/golden_tests/compile_file/elif_no_else.bend : - expected: 'else' or 'elif' - detected: end of input  6 |   ================================================ FILE: tests/snapshots/compile_file__erased_dup.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/erased_dup.bend --- @main = ({* a} a) ================================================ FILE: tests/snapshots/compile_file__error_data_def_name.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/error_data_def_name.bend --- Errors: In tests/golden_tests/compile_file/error_data_def_name.bend : Redefinition of constructor 'A/A'. Location:  2 | A/A = 0 ================================================ FILE: tests/snapshots/compile_file__error_messages.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/error_messages.bend --- Errors: In tests/golden_tests/compile_file/error_messages.bend : In definition 'Foo': Unbound constructor 'C' in pattern matching rule. Unbound constructor 'D' in pattern matching rule. In definition 'Foo2': Unbound constructor 'E' in pattern matching rule. ================================================ FILE: tests/snapshots/compile_file__f24_oper.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/f24_oper.bend --- @main = b & $(1.2399902 $([/] $(a b))) ~ [*0x042F830] & $(-235.1211 a) ~ [+0x0000000] ================================================ FILE: tests/snapshots/compile_file__fst_snd.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/fst_snd.bend --- @main = d & ((* a) a) ~ (c d) & ((b *) b) ~ (((1 3) 2) c) ================================================ FILE: tests/snapshots/compile_file__global_lam.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/global_lam.bend --- @main = c & (b (a a)) ~ (b c) ================================================ FILE: tests/snapshots/compile_file__i24_oper.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/i24_oper.bend --- @main = b & $(-1 $([*] $(a b))) ~ [+0x0000001] & $(+14 a) ~ [-0x7FFFFF4] ================================================ FILE: tests/snapshots/compile_file__id.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/id.bend --- @main = (a a) ================================================ FILE: tests/snapshots/compile_file__infer_dup.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/infer_dup.bend --- @main = ({(a b) a} b) ================================================ FILE: tests/snapshots/compile_file__inlining.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/inlining.bend --- @Era = * @Num = 42 @RefToRef = @Era @main = a & @Era ~ (@Num (@RefToRef a)) ================================================ FILE: tests/snapshots/compile_file__just_a_name.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/just_a_name.bend --- Errors: In tests/golden_tests/compile_file/just_a_name.bend : - expected: pattern or '=' - detected: end of input  1 | asdf ================================================ FILE: tests/snapshots/compile_file__just_data.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/just_data.bend --- Errors: In tests/golden_tests/compile_file/just_data.bend : - expected: Datatype name - detected: end of input  1 | type  ================================================ FILE: tests/snapshots/compile_file__just_paren.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/just_paren.bend --- Errors: In tests/golden_tests/compile_file/just_paren.bend : - expected: Function name - detected: end of input  2 | (  ================================================ FILE: tests/snapshots/compile_file__just_rule_paren.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/just_rule_paren.bend --- Errors: In tests/golden_tests/compile_file/just_rule_paren.bend : - expected: '=' - detected: end of input  1 | (rule)  ================================================ FILE: tests/snapshots/compile_file__let_substitution.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/let_substitution.bend --- @main = ({(a b) a} b) ================================================ FILE: tests/snapshots/compile_file__let_tup.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/let_tup.bend --- @main = ((a (* a)) (* (b b))) ================================================ FILE: tests/snapshots/compile_file__lets.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/lets.bend --- @main = o & (a a) ~ (g (j (n o))) & (e e) ~ * & (d d) ~ {(f g) f} & (c c) ~ {(h (i j)) {h i}} & (b b) ~ {(k (l (m n))) {k {l m}}} ================================================ FILE: tests/snapshots/compile_file__long_name.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/long_name.bend --- @WowThis_is_a_very_long_name_no_way_ItFits = (a a) @main = (* a) & @WowThis_is_a_very_long_name_no_way_ItFits ~ (* a) ================================================ FILE: tests/snapshots/compile_file__match.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/match.bend --- @main = c & $(1 ?(((a (* a)) (* (* (b b)))) c)) ~ [+0x0000000] ================================================ FILE: tests/snapshots/compile_file__mismatched_ask_statements.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/mismatched_ask_statements.bend --- Errors: In tests/golden_tests/compile_file/mismatched_ask_statements.bend : In definition 'main': 'match' arms end with different assignments. ================================================ FILE: tests/snapshots/compile_file__missing_adt_eq.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/missing_adt_eq.bend --- Errors: In tests/golden_tests/compile_file/missing_adt_eq.bend : - expected: Type variable or '=' - detected: end of input  1 | type Adt  ================================================ FILE: tests/snapshots/compile_file__missing_ctrs.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/missing_ctrs.bend --- Errors: In tests/golden_tests/compile_file/missing_ctrs.bend : - expected: Datatype constructor name - detected: end of input  1 | type Adt =  ================================================ FILE: tests/snapshots/compile_file__missing_pat.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/missing_pat.bend --- Errors: In tests/golden_tests/compile_file/missing_pat.bend : - expected: name or '*' - detected:  2 | : * ================================================ FILE: tests/snapshots/compile_file__names_starting_with_keywords.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/names_starting_with_keywords.bend --- @A = (a a) @B = (a a) @C = (a a) @D = (a a) @E = (a a) @main = * ================================================ FILE: tests/snapshots/compile_file__nested_ctr_wrong_arity.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/nested_ctr_wrong_arity.bend --- Errors: In tests/golden_tests/compile_file/nested_ctr_wrong_arity.bend : In definition 'fst_fst': Incorrect arity for constructor 'Pair/Pair' of type 'Pair' in pattern matching rule. Expected 2 fields, found 1 ================================================ FILE: tests/snapshots/compile_file__nested_let.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/nested_let.bend --- @main = a & ((2 4) (3 6)) ~ (* (a *)) ================================================ FILE: tests/snapshots/compile_file__number_too_large.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/number_too_large.bend --- Errors: In tests/golden_tests/compile_file/number_too_large.bend : Number literal outside of range for U24. Location: end of input  1 | main = 0x10000000 ================================================ FILE: tests/snapshots/compile_file__nums.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/nums.bend --- @main = b & $(a b) ~ [+0x0FFFFFF] & $(1000 a) ~ [+0x0000005] ================================================ FILE: tests/snapshots/compile_file__op2.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/op2.bend --- @main = a & $(1 $([=0x0000002] $([&0x0000003] $([|0x0000004] $([<0x0000005] $([>0x0000006] $([:/0x0000007] $([*0x0000008] $([:-0x0000009] $([+0x000000A] $([:%0x000000B] a))))))))))) ~ [!0x0000000] ================================================ FILE: tests/snapshots/compile_file__redex_order.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/redex_order.bend --- @a = (a a) @b = (a a) @c = (a a) @foo = (a d) & @a ~ (c d) & @b ~ (b c) & @c ~ (a b) @foo2 = c & @a ~ (b c) & @b ~ (a b) & @c ~ (0 a) @main = a & @foo ~ (@foo2 a) ================================================ FILE: tests/snapshots/compile_file__redex_order_recursive.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/redex_order_recursive.bend --- @Foo = (a (b (c ((a (b (c d))) d)))) @List.concat = ((@List.concat__C1 a) a) @List.concat__C0 = (* (a (b (c e)))) & @List/Cons ~ (a (d e)) & @List.concat ~ (b (c d)) @List.concat__C1 = (?(((a a) @List.concat__C0) b) b) @List.fold = ((@List.fold__C1 a) a) @List.fold__C0 = (* (a (b ({(a (e f)) c} (d f))))) & @List.fold ~ (b (c (d e))) @List.fold__C1 = (?(((* (a a)) @List.fold__C0) b) b) @List.len = ((@List.len__C1 a) a) @List.len__C0 = (* (* (a c))) & $(b c) ~ [+0x0000001] & @List.len ~ (a b) @List.len__C1 = (?((0 @List.len__C0) a) a) @List.len_tr = ((@List.len_tr__C1 a) a) @List.len_tr__C0 = (* (* (a (b d)))) & @List.len_tr ~ (a (c d)) & $(b c) ~ [+0x0000001] @List.len_tr__C1 = (?(((a a) @List.len_tr__C0) b) b) @List.map = ((@List.map__C1 a) a) @List.map__C0 = (* (a (c ({(a b) d} f)))) & @List/Cons ~ (b (e f)) & @List.map ~ (c (d e)) @List.map__C1 = (?(((* @List/Nil) @List.map__C0) a) a) @List.reduce = ((@List.reduce__C1 a) a) @List.reduce__C0 = (* (d (a ({b (c (d e))} (c f))))) & @List.reduce ~ (a (b (e f))) @List.reduce__C1 = (?(((* (a a)) @List.reduce__C0) b) b) @List.reverse_bad = ((@List.reverse_bad__C1 a) a) @List.reverse_bad__C0 = (* (c (a e))) & @List.concat ~ (b (d e)) & @List.reverse_bad ~ (a b) & @List/Cons ~ (c (@List/Nil d)) @List.reverse_bad__C1 = (?((@List/Nil @List.reverse_bad__C0) a) a) @List.reverse_over = ((@List.reverse_over__C1 a) a) @List.reverse_over__C0 = (* (b (a (c e)))) & @List.reverse_over ~ (a (d e)) & @List/Cons ~ (b (c d)) @List.reverse_over__C1 = (?(((a a) @List.reverse_over__C0) b) b) @List.reverse_tr = (a (* b)) & @List.reverse_over ~ (a (@List/Nil b)) @List.sum = ((@List.sum__C1 a) a) @List.sum__C0 = (* ($([+] $(b c)) (a (b d)))) & @List.sum ~ (a (c d)) @List.sum__C1 = (?(((a a) @List.sum__C0) b) b) @List/Cons = (a (b ((@List/Cons/tag (a (b c))) c))) @List/Cons/tag = 1 @List/Nil = ((@List/Nil/tag a) a) @List/Nil/tag = 0 @Tree.flip = ((@Tree.flip__C2 a) a) @Tree.flip__C0 = (c (a e)) & @Tree/Node ~ (b (d e)) &!@Tree.flip ~ (a b) &!@Tree.flip ~ (c d) @Tree.flip__C1 = (* a) & @Tree/Leaf ~ a @Tree.flip__C2 = (?((@Tree.flip__C0 @Tree.flip__C1) a) a) @Tree.height = ((@Tree.height__C1 a) a) @Tree.height__C0 = (a (c f)) & $(e f) ~ [+0x0000001] & @max ~ (b (d e)) &!@Tree.height ~ (a b) &!@Tree.height ~ (c d) @Tree.height__C1 = (?((@Tree.height__C0 (* (* 0))) a) a) @Tree.leaves = ((@Tree.leaves__C1 a) a) @Tree.leaves__C0 = (a (b d)) &!@Tree.leaves ~ (a $([+] $(c d))) &!@Tree.leaves ~ (b c) @Tree.leaves__C1 = (?((@Tree.leaves__C0 (* (* 1))) a) a) @Tree.map = ((@Tree.map__C2 a) a) @Tree.map__C0 = (a (d ({b e} g))) & @Tree/Node ~ (c (f g)) &!@Tree.map ~ (a (b c)) &!@Tree.map ~ (d (e f)) @Tree.map__C1 = (* (a ((a b) c))) & @Tree/Leaf ~ (b c) @Tree.map__C2 = (?((@Tree.map__C0 @Tree.map__C1) a) a) @Tree.nodes = ((@Tree.nodes__C1 a) a) @Tree.nodes__C0 = (a (b e)) & $(d e) ~ [+0x0000001] &!@Tree.nodes ~ (a $([+] $(c d))) &!@Tree.nodes ~ (b c) @Tree.nodes__C1 = (?((@Tree.nodes__C0 (* (* 0))) a) a) @Tree/Leaf = (a ((@Tree/Leaf/tag (a b)) b)) @Tree/Leaf/tag = 1 @Tree/Node = (a (b ((@Tree/Node/tag (a (b c))) c))) @Tree/Node/tag = 0 @add = ((@add__C0 ((a a) b)) b) @add__C0 = (a (b d)) & @add ~ (a (((b c) (* c)) d)) @calc = l & @Foo ~ (f (h (k l))) & 1 ~ {$([+] $(e f)) {$([*] $(a {e {$([*] $(b {$([+] $(g h)) {$([*] $(c {g {$([*] $(d {$([+] $(j k)) {$([*] $(i j)) i}})) d}})) c}})) b}})) a}} @fold_ = ((@fold___C1 (@fold___C0 a)) a) @fold___C0 = (((* (a a)) b) (* b)) @fold___C1 = (a (c e)) & @add ~ (b (d e)) &!@fold_ ~ (a b) &!@fold_ ~ (c d) @main = * @max = ({$([>] $(a ?(((* (b b)) (* (c (* c)))) (d (e f))))) d} ({a e} f)) @tail_recursive = ((@tail_recursive__C0 ((* 0) a)) a) @tail_recursive__C0 = (a (b d)) & @tail_recursive ~ (a (c d)) & $(b c) ~ [+0x0000001] ================================================ FILE: tests/snapshots/compile_file__ref_to_main.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/ref_to_main.bend --- Errors: In definition 'Foo': Main definition can't be referenced inside the program. ================================================ FILE: tests/snapshots/compile_file__ref_to_ref.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/ref_to_ref.bend --- @A1 = @A2 @A2 = 1 @B1 = @B2 @B2 = @B3 @B3 = @B4 @B4 = @B5 @B5 = 2 @C1 = @B4 @main = ((1 2) 2) ================================================ FILE: tests/snapshots/compile_file__repeated_bind_rule.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/repeated_bind_rule.bend --- Warnings: In tests/golden_tests/compile_file/repeated_bind_rule.bend : In definition 'Foo': Repeated bind in pattern matching rule: 'a'. @Foo = (* (a a)) @main = a & @Foo ~ (1 (2 a)) ================================================ FILE: tests/snapshots/compile_file__simple_tup.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/simple_tup.bend --- @main = (0 42) ================================================ FILE: tests/snapshots/compile_file__switch_all_patterns.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/switch_all_patterns.bend --- Errors: In tests/golden_tests/compile_file/switch_all_patterns.bend : - expected: '0' - detected:  7 | _: x-1 ================================================ FILE: tests/snapshots/compile_file__switch_in_switch_arg.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/switch_in_switch_arg.bend --- @main = (?((0 (a a)) ?((0 ($([+0x0000001] b) b)) c)) c) ================================================ FILE: tests/snapshots/compile_file__switch_incomplete.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/switch_incomplete.bend --- Errors: In tests/golden_tests/compile_file/switch_incomplete.bend : - expected: term - detected:  2 | main = switch {} ================================================ FILE: tests/snapshots/compile_file__switch_unscoped_lambda.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/switch_unscoped_lambda.bend --- @lambda_in = (?(((a a) (b (c b))) (c d)) d) @lambda_out = (?((a (b b)) c) (a c)) @main = * ================================================ FILE: tests/snapshots/compile_file__top_level_name_slashslash.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/top_level_name_slashslash.bend --- Errors: In tests/golden_tests/compile_file/top_level_name_slashslash.bend : Top-level names are not allowed to start with "//". Location:  4 | def //thisshouldfail(): ================================================ FILE: tests/snapshots/compile_file__tup.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/tup.bend --- @main = ((1 4) (2 3)) ================================================ FILE: tests/snapshots/compile_file__tup_add.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/tup_add.bend --- @main = b & (1 2) ~ ($([+] $(a b)) a) ================================================ FILE: tests/snapshots/compile_file__unbound_unscoped_var.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/unbound_unscoped_var.bend --- Errors: In tests/golden_tests/compile_file/unbound_unscoped_var.bend : In definition 'main': Unbound unscoped variable '$a'. ================================================ FILE: tests/snapshots/compile_file__unbound_var.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/unbound_var.bend --- Errors: In tests/golden_tests/compile_file/unbound_var.bend : In definition 'main': Unbound variable 'a'. ================================================ FILE: tests/snapshots/compile_file__unbound_var_scope.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/unbound_var_scope.bend --- Errors: In tests/golden_tests/compile_file/unbound_var_scope.bend : In definition 'main': Unbound variable 'b'. ================================================ FILE: tests/snapshots/compile_file__unbound_with_tup_pattern.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/unbound_with_tup_pattern.bend --- Errors: In tests/golden_tests/compile_file/unbound_with_tup_pattern.bend : In definition 'Foo': Unbound variable 'a'. ================================================ FILE: tests/snapshots/compile_file__underscore.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/underscore.bend --- @const = (* 2) @main = a & @const ~ (0 a) ================================================ FILE: tests/snapshots/compile_file__unexpected_top_char.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/unexpected_top_char.bend --- Errors: In tests/golden_tests/compile_file/unexpected_top_char.bend : - expected: top-level definition - detected:  1 | * ================================================ FILE: tests/snapshots/compile_file__unscoped_dup_use.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/unscoped_dup_use.bend --- Errors: In tests/golden_tests/compile_file/unscoped_dup_use.bend : In definition 'main': Unscoped variable '$a' used more than once. ================================================ FILE: tests/snapshots/compile_file__unscoped_supercombinator.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/unscoped_supercombinator.bend --- @Foo = ((@Foo__C1 (@Foo__C0 a)) a) @Foo__C0 = (a ((a b) b)) @Foo__C1 = (a ((a b) b)) @main = a & @Foo ~ (* a) ================================================ FILE: tests/snapshots/compile_file__unused_let.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/unused_let.bend --- @main = ({$([+] $(b *)) {b a}} a) ================================================ FILE: tests/snapshots/compile_file__unused_unscoped_bind.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/unused_unscoped_bind.bend --- Errors: In tests/golden_tests/compile_file/unused_unscoped_bind.bend : In definition 'main': Unscoped variable from lambda 'λ$a' is never used. ================================================ FILE: tests/snapshots/compile_file__variable_name_double_underscore.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/variable_name_double_underscore.bend --- Errors: In tests/golden_tests/compile_file/variable_name_double_underscore.bend : - expected: expression - detected:  2 | return __this_should_fail__(*) ================================================ FILE: tests/snapshots/compile_file__vicious_circles.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/vicious_circles.bend --- Errors: In compiled inet 'disconnected_self_lam': Found term that compiles into an inet with a vicious cycle In compiled inet 'dup_self': Found term that compiles into an inet with a vicious cycle In compiled inet 'main': Found term that compiles into an inet with a vicious cycle ================================================ FILE: tests/snapshots/compile_file__warn_and_err.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/warn_and_err.bend --- Warnings: In tests/golden_tests/compile_file/warn_and_err.bend : In definition 'Foo': Repeated bind in pattern matching rule: 'a'. Errors: In tests/golden_tests/compile_file/warn_and_err.bend : In definition 'Main': Unbound variable 'a'. ================================================ FILE: tests/snapshots/compile_file__with_clause_parse_err.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/with_clause_parse_err.bend --- Errors: In tests/golden_tests/compile_file/with_clause_parse_err.bend : - expected: '{' - detected:  1 | main = @a @b switch b witha{ ================================================ FILE: tests/snapshots/compile_file__wrong_ctr_arity.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/wrong_ctr_arity.bend --- Errors: In tests/golden_tests/compile_file/wrong_ctr_arity.bend : In definition 'Bar': Incorrect arity for constructor 'Boxed/Box' of type 'Boxed' in pattern matching rule. Expected 1 fields, found 2 ================================================ FILE: tests/snapshots/compile_file__wrong_ctr_var_arity.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/wrong_ctr_var_arity.bend --- Errors: In tests/golden_tests/compile_file/wrong_ctr_var_arity.bend : In definition 'foo': Incorrect arity for constructor 'Tup/pair' of type 'Tup' in pattern matching rule. Expected 2 fields, found 0 ================================================ FILE: tests/snapshots/compile_file__wrong_nums.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/wrong_nums.bend --- Errors: In tests/golden_tests/compile_file/wrong_nums.bend : - expected: valid binary digit - detected:  1 | main = (+ 0b012345 0FA) ================================================ FILE: tests/snapshots/compile_file__wrong_unicode_escape.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file/wrong_unicode_escape.bend --- Errors: In tests/golden_tests/compile_file/wrong_unicode_escape.bend : - expected: '}' - detected:  1 | main = (String.cons '\u{1' "\u2}\u{zxcx}") ================================================ FILE: tests/snapshots/compile_file_o_all__addition.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/addition.bend --- @main = c & (a b) ~ (8 c) & $(1 $([+] $(a b))) ~ [+0x0000001] ================================================ FILE: tests/snapshots/compile_file_o_all__addition_var_fst.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/addition_var_fst.bend --- @main = ($([+0x0000001] a) a) ================================================ FILE: tests/snapshots/compile_file_o_all__adt_option_and.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/adt_option_and.bend --- @Option/None = ((1 a) a) @Option/Some = (a ((0 (a b)) b)) @Option/and = ((@Option/and__C3 a) a) @Option/and__C0 = (b (a c)) & @Option/Some ~ ((a b) c) @Option/and__C1 = (?((@Option/and__C0 (* (* @Option/None))) a) a) @Option/and__C2 = (a ((@Option/and__C1 (a b)) b)) @Option/and__C3 = (?((@Option/and__C2 (* (* @Option/None))) a) a) @main = c & @Option/and ~ (a (b c)) & @Option/Some ~ (1 a) & @Option/Some ~ (3 b) ================================================ FILE: tests/snapshots/compile_file_o_all__adt_string.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/adt_string.bend --- Errors: In tests/golden_tests/compile_file_o_all/adt_string.bend : Redefinition of builtin (type) 'String'. Location:  1 | type String = S  2 |   3 | main = String/S ================================================ FILE: tests/snapshots/compile_file_o_all__and.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/and.bend --- @and = (a ((@and__C0 (a b)) b)) @and__C0 = (?(((a a) (* (* @bool/false))) b) b) @bool/false = ((1 a) a) @bool/true = ((0 a) a) @main = a & @and ~ (@bool/true (@bool/false a)) ================================================ FILE: tests/snapshots/compile_file_o_all__bad_parens_making_erased_let.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/bad_parens_making_erased_let.bend --- Errors: In tests/golden_tests/compile_file_o_all/bad_parens_making_erased_let.bend : In definition 'main': Unbound variable 'two'. Unbound variable 'qua'. ================================================ FILE: tests/snapshots/compile_file_o_all__bool.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/bool.bend --- @Not = ((@fals (@true a)) a) @fals = (* (a a)) @main = a & @Not ~ (@true a) @true = (a (* a)) ================================================ FILE: tests/snapshots/compile_file_o_all__cyclic_dup.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/cyclic_dup.bend --- Errors: In tests/golden_tests/compile_file_o_all/cyclic_dup.bend : In definition 'main': Unbound variable 'y1'. ================================================ FILE: tests/snapshots/compile_file_o_all__double_main.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/double_main.bend --- Errors: File has both 'main' and 'Main' definitions. ================================================ FILE: tests/snapshots/compile_file_o_all__eta_chain.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/eta_chain.bend --- @Bar = a & @Baz ~ a @Baz = ($([+] $(b c)) ($([+] $(a b)) (a c))) @Foo = a & @Bar ~ a @main = a & @Foo ~ a ================================================ FILE: tests/snapshots/compile_file_o_all__ex0.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/ex0.bend --- @C_2 = ({(b c) (a b)} (a c)) @S = (a ((a b) (* b))) @Z = (* (a a)) @main = a & @C_2 ~ (@S (@Z a)) ================================================ FILE: tests/snapshots/compile_file_o_all__ex2.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/ex2.bend --- @E = (* (* (a a))) @I = (a (* ((a b) (* b)))) @O = (a ((a b) (* (* b)))) @c2 = ({(b c) (a b)} (a c)) @dec = ((@decO (@decI (@E a))) a) @decI = a & @low ~ a @decO = (a c) & @I ~ (b c) & @dec ~ (a b) @low = ((@lowO (@lowI (@E a))) a) @lowI = (a c) & @O ~ (b c) & @I ~ (a b) @lowO = (a c) & @O ~ (b c) & @O ~ (a b) @main = b & @run ~ (a b) & @c2 ~ (@I (@E a)) @run = ((@runO (@runI (@E a))) a) @runI = (a d) & @run ~ (c d) & @dec ~ (b c) & @I ~ (a b) @runO = (a d) & @run ~ (c d) & @dec ~ (b c) & @O ~ (a b) ================================================ FILE: tests/snapshots/compile_file_o_all__example.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/example.bend --- @Def1 = c & (a a) ~ ((b b) c) @Def2 = b & (a a) ~ (@Def1 b) @main = a & @Def2 ~ (1 a) ================================================ FILE: tests/snapshots/compile_file_o_all__exp.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/exp.bend --- @main = g & ({(b c) (a b)} (a c)) ~ (({(e f) (d e)} (d f)) g) ================================================ FILE: tests/snapshots/compile_file_o_all__expr.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/expr.bend --- @Expr/App = (a (b ((2 (a (b c))) c))) @Expr/Dup = (a (b (c (d ((6 (a (b (c (d e))))) e))))) @Expr/Let = (a (b (c ((5 (a (b (c d)))) d)))) @Expr/Num = (a ((1 (a b)) b)) @Expr/Op2 = (a (b (c ((8 (a (b (c d)))) d)))) @Expr/Var = (a ((0 (a b)) b)) @Op/Mul = ((2 a) a) @Op/Sub = ((1 a) a) @main = n & @Expr/Let ~ (a (f (m n))) & @Expr/Var ~ (0 a) & @Expr/Op2 ~ (@Op/Mul (e f)) & @Expr/Op2 ~ (@Op/Sub (b (c (d e)))) & @Expr/Num ~ (2 b) & @Expr/Num ~ (1 c) & @Expr/Num ~ (3 d) & @Expr/Dup ~ (g (h (i (l m)))) & @Expr/Var ~ (1 g) & @Expr/Var ~ (2 h) & @Expr/Var ~ (0 i) & @Expr/App ~ (j (k l)) & @Expr/Var ~ (1 j) & @Expr/Var ~ (2 k) ================================================ FILE: tests/snapshots/compile_file_o_all__extracted_match_pred.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/extracted_match_pred.bend --- @main = a & @val ~ (1 a) @val = (?((0 @val__C0) a) a) @valS = a & @val ~ a @val__C0 = a & @valS ~ a ================================================ FILE: tests/snapshots/compile_file_o_all__fst.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/fst.bend --- @Fst = ((a *) a) @main = a & @Fst ~ ((4 8) a) ================================================ FILE: tests/snapshots/compile_file_o_all__fst_fst.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/fst_fst.bend --- @FstFst = ((a *) ((b *) (a b))) @main = a & @FstFst ~ ((3 9) ((4 12) a)) ================================================ FILE: tests/snapshots/compile_file_o_all__hvm1_main.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/hvm1_main.bend --- @main = (a a) ================================================ FILE: tests/snapshots/compile_file_o_all__inline_app.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/inline_app.bend --- @Rul1__M_Rul2 = (a a) @Rul3 = a & @Rul1__M_Rul2 ~ (@Rul1__M_Rul2 a) @main = a & @Rul3 ~ (@Rul3 a) ================================================ FILE: tests/snapshots/compile_file_o_all__inlining.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/inlining.bend --- @main = a & * ~ (42 (* a)) ================================================ FILE: tests/snapshots/compile_file_o_all__linearize_match.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/linearize_match.bend --- @main = (?(((a a) ($([+] $(b c)) (b c))) d) d) ================================================ FILE: tests/snapshots/compile_file_o_all__list_merge_sort.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/list_merge_sort.bend --- @If = ((@If__C0 a) a) @If__C0 = (?(((a (* a)) (* (* (b b)))) c) c) @List_/Cons = (a (b ((0 (a (b c))) c))) @List_/Nil = ((1 a) a) @Map = ((@Map__C1 a) a) @Map__C0 = (a (c ({(a b) d} f))) & @List_/Cons ~ (b (e f)) & @Map ~ (c (d e)) @Map__C1 = (?((@Map__C0 (* (* @List_/Nil))) a) a) @Merge = (a ((@Merge__C4 (a b)) b)) @MergePair = (a ((@MergePair__C4 (a b)) b)) @MergePair__C0 = (c (f ({a e} (b h)))) & @List_/Cons ~ (d (g h)) & @Merge ~ (a (b (c d))) & @MergePair ~ (e (f g)) @MergePair__C1 = (* (* (a b))) & @List_/Cons ~ (a (@List_/Nil b)) @MergePair__C2 = (?((@MergePair__C0 @MergePair__C1) a) a) @MergePair__C3 = (b ((@MergePair__C2 (a (b c))) (a c))) @MergePair__C4 = (?((@MergePair__C3 (* (* @List_/Nil))) a) a) @Merge__C0 = ({b {g l}} ({h q} ({(a (b c)) {e m}} ({a {d n}} ({f o} t))))) & @If ~ (c (k (s t))) & @List_/Cons ~ (d (j k)) &!@Merge ~ (e (f (i j))) & @List_/Cons ~ (g (h i)) & @List_/Cons ~ (l (r s)) &!@Merge ~ (m (p (q r))) & @List_/Cons ~ (n (o p)) @Merge__C1 = (* (* a)) & @List_/Cons ~ a @Merge__C2 = (?((@Merge__C0 @Merge__C1) a) a) @Merge__C3 = (b (c (a ((@Merge__C2 (a (b (c d)))) d)))) @Merge__C4 = (?((@Merge__C3 (* (* (a a)))) b) b) @Pure = (a b) & @List_/Cons ~ (a (@List_/Nil b)) @Unpack = (a ((@Unpack__C3 (a b)) b)) @Unpack__C0 = (d (e ({a b} (c i)))) & @Unpack ~ (a (h i)) & @MergePair ~ (b (g h)) & @List_/Cons ~ (c (f g)) & @List_/Cons ~ (d (e f)) @Unpack__C1 = (?((@Unpack__C0 (* (* (a a)))) b) b) @Unpack__C2 = (b ((@Unpack__C1 (a (b c))) (a c))) @Unpack__C3 = (?((@Unpack__C2 (* (* @List_/Nil))) a) a) @main = (a (b d)) & @Unpack ~ (a (c d)) & @Map ~ (b (@Pure c)) ================================================ FILE: tests/snapshots/compile_file_o_all__list_reverse.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/list_reverse.bend --- @concat = ((@concat__C1 a) a) @concat__C0 = (a (b (c e))) & @list/cons ~ (a (d e)) & @concat ~ (b (c d)) @concat__C1 = (?((@concat__C0 (* (a a))) b) b) @list/cons = (a (b ((0 (a (b c))) c))) @list/nil = ((1 a) a) @main = d & @reverse ~ (c d) & @list/cons ~ (3 (b c)) & @list/cons ~ (2 (a b)) & @list/cons ~ (1 (@list/nil a)) @reverse = ((@reverse__C1 a) a) @reverse__C0 = (c (a e)) & @concat ~ (b (d e)) & @reverse ~ (a b) & @list/cons ~ (c (@list/nil d)) @reverse__C1 = (?((@reverse__C0 (* @list/nil)) a) a) ================================================ FILE: tests/snapshots/compile_file_o_all__match_adt_non_exhaustive.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/match_adt_non_exhaustive.bend --- Errors: In tests/golden_tests/compile_file_o_all/match_adt_non_exhaustive.bend : In definition 'main': Non-exhaustive 'match' expression of type 'Maybe_'. Case 'Maybe_/Some' not covered. ================================================ FILE: tests/snapshots/compile_file_o_all__match_dup_and_reconstruction.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/match_dup_and_reconstruction.bend --- @Box/Boxed = (a ((0 (a b)) b)) @Got = ((@Got__C1 a) a) @Got__C0 = ({a c} (b c)) & @Box/Boxed ~ (a b) @Got__C1 = (?((@Got__C0 *) a) a) @main = b & @Got ~ (a b) & @Box/Boxed ~ (10 a) ================================================ FILE: tests/snapshots/compile_file_o_all__match_mult_linearization.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/match_mult_linearization.bend --- @main = (?((($([+] $(a $([+] $(b c)))) (a (b c))) ($([+] $(d $([+] $(e $([+] $(f g)))))) (d (e (f g))))) h) h) ================================================ FILE: tests/snapshots/compile_file_o_all__match_num_explicit_bind.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/match_num_explicit_bind.bend --- @main = a & @pred ~ (4 a) @pred = (?((0 (a a)) b) b) ================================================ FILE: tests/snapshots/compile_file_o_all__match_tup.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/match_tup.bend --- @Sum = (($([+] $(a b)) a) b) @main = a & @Sum ~ ((7 3) a) ================================================ FILE: tests/snapshots/compile_file_o_all__merge_definitions.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/merge_definitions.bend --- @false__M_snd = (* (a a)) @main = (* b) & @true__M_fst ~ (@true__M_fst (a b)) & @false__M_snd ~ (@false__M_snd (* a)) @true__M_fst = (a (* a)) ================================================ FILE: tests/snapshots/compile_file_o_all__non_exhaustive_and.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/non_exhaustive_and.bend --- Errors: In tests/golden_tests/compile_file_o_all/non_exhaustive_and.bend : In definition 'Bool.and': Non-exhaustive pattern matching rule. Constructor 'Bool/F' of type 'Bool' not covered ================================================ FILE: tests/snapshots/compile_file_o_all__non_exhaustive_different_types.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/non_exhaustive_different_types.bend --- Errors: In tests/golden_tests/compile_file_o_all/non_exhaustive_different_types.bend : In definition 'foo': Non-exhaustive pattern matching rule. Constructor 'b3/t3' of type 'b3' not covered ================================================ FILE: tests/snapshots/compile_file_o_all__non_exhaustive_pattern.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/non_exhaustive_pattern.bend --- Errors: In tests/golden_tests/compile_file_o_all/non_exhaustive_pattern.bend : In definition 'Foo': Non-exhaustive pattern matching rule. Constructor 'Type/A' of type 'Type' not covered ================================================ FILE: tests/snapshots/compile_file_o_all__non_exhaustive_tree.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/non_exhaustive_tree.bend --- Errors: In tests/golden_tests/compile_file_o_all/non_exhaustive_tree.bend : In definition 'Warp': Non-exhaustive pattern matching rule. Constructor 'Tree/Leaf' of type 'Tree' not covered ================================================ FILE: tests/snapshots/compile_file_o_all__num_pattern_with_var.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/num_pattern_with_var.bend --- @Foo = ((@Foo__C2 a) a) @Foo__C0 = ($([+0x0000001] a) a) @Foo__C1 = (* (?((0 @Foo__C0) a) a)) @Foo__C2 = (?(((* 0) @Foo__C1) a) a) @bool/true = ((1 a) a) @main = a & @Foo ~ (@bool/true (3 a)) ================================================ FILE: tests/snapshots/compile_file_o_all__recursive_combinator_inactive.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/recursive_combinator_inactive.bend --- @Foo = (?((@Foo__C0 (a (* a))) b) b) @Foo__C0 = {@Foo @Foo} @main = a & @Foo ~ (0 a) ================================================ FILE: tests/snapshots/compile_file_o_all__repeated_name_trucation.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/repeated_name_trucation.bend --- Warnings: The following functions contain recursive cycles incompatible with HVM's strict evaluation: * long_name_that_truncates -> long_name_that_truncates The greedy eager evaluation of HVM may cause infinite loops. Refactor these functions to use lazy references instead of direct function calls. A reference is strict when it's being called ('(Foo x)') or when it's used non-linearly ('let x = Foo; (x x)'). It is lazy when it's an argument ('(x Foo)') or when it's used linearly ('let x = Foo; (x 0)'). Try one of these strategies: - Use pattern matching with 'match', 'fold', and 'bend' to automatically lift expressions to lazy references. - Replace direct calls with combinators. For example, change: 'Foo = λa λb (b (λc (Foo a c)) a)' to: 'Foo = λa λb (b (λc λa (Foo a c)) (λa a) a)' which is lifted to: 'Foo = λa λb (b Foo__C1 Foo__C2 a)' - Replace non-linear 'let' expressions with 'use' expressions. For example, change: 'Foo = λf let x = Foo; (f x x)' to: 'Foo = λf use x = Foo; (f x x)' which inlines to: 'Foo = λf (f Foo Foo)' - If disabled, re-enable the default 'float-combinators' and 'linearize-matches' compiler options. For more information, visit: https://github.com/HigherOrderCO/Bend/blob/main/docs/lazy-definitions.md. To disable this check, use the "-Arecursion-cycle" compiler option. @long_name_that_truncates = (* (* @long_name_that_truncates)) @long_name_that_truncates_too = (a a) @main = a & @long_name_that_truncates ~ (@long_name_that_truncates_too a) ================================================ FILE: tests/snapshots/compile_file_o_all__scrutinee_reconstruction.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/scrutinee_reconstruction.bend --- @Option/None = ((1 a) a) @Option/Some = (a ((0 (a b)) b)) @Option/or = ((@Option/or__C1 a) a) @Option/or__C0 = (a (* b)) & @Option/Some ~ (a b) @Option/or__C1 = (?((@Option/or__C0 (* (a a))) b) b) @main = b & @Option/or ~ (a (@Option/None b)) & @Option/Some ~ (5 a) ================================================ FILE: tests/snapshots/compile_file_o_all__self_ref.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/self_ref.bend --- Warnings: The following functions contain recursive cycles incompatible with HVM's strict evaluation: * Foo -> Foo The greedy eager evaluation of HVM may cause infinite loops. Refactor these functions to use lazy references instead of direct function calls. A reference is strict when it's being called ('(Foo x)') or when it's used non-linearly ('let x = Foo; (x x)'). It is lazy when it's an argument ('(x Foo)') or when it's used linearly ('let x = Foo; (x 0)'). Try one of these strategies: - Use pattern matching with 'match', 'fold', and 'bend' to automatically lift expressions to lazy references. - Replace direct calls with combinators. For example, change: 'Foo = λa λb (b (λc (Foo a c)) a)' to: 'Foo = λa λb (b (λc λa (Foo a c)) (λa a) a)' which is lifted to: 'Foo = λa λb (b Foo__C1 Foo__C2 a)' - Replace non-linear 'let' expressions with 'use' expressions. For example, change: 'Foo = λf let x = Foo; (f x x)' to: 'Foo = λf use x = Foo; (f x x)' which inlines to: 'Foo = λf (f Foo Foo)' - If disabled, re-enable the default 'float-combinators' and 'linearize-matches' compiler options. For more information, visit: https://github.com/HigherOrderCO/Bend/blob/main/docs/lazy-definitions.md. To disable this check, use the "-Arecursion-cycle" compiler option. Errors: During inlining: infinite reference cycle in `@Foo` ================================================ FILE: tests/snapshots/compile_file_o_all__snd.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/snd.bend --- @main = a & @snd ~ ((0 42) a) @snd = ((* a) a) ================================================ FILE: tests/snapshots/compile_file_o_all__spacing.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/spacing.bend --- @main = ({b c} d) & (a a) ~ (b (c d)) ================================================ FILE: tests/snapshots/compile_file_o_all__spacing2.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/spacing2.bend --- @main = c & (a a) ~ ((b b) c) ================================================ FILE: tests/snapshots/compile_file_o_all__str.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/str.bend --- @String/Cons = (a (b ((1 (a (b c))) c))) @String/Nil = ((0 a) a) @main = f & @String/Cons ~ (109 (e f)) & @String/Cons ~ (97 (d e)) & @String/Cons ~ (105 (c d)) & @String/Cons ~ (110 (b c)) & @String/Cons ~ (32 (a b)) & @String/Cons ~ (61 (@String/Nil a)) ================================================ FILE: tests/snapshots/compile_file_o_all__sum_predicates.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/sum_predicates.bend --- @main = a & @sum_pred ~ (8 (5 a)) @sum_pred = (?((@sum_pred__C1 @sum_pred__C2) a) a) @sum_pred__C0 = (a ($([+] $(a b)) b)) @sum_pred__C1 = (?((0 (a a)) b) b) @sum_pred__C2 = (b (?(((a a) @sum_pred__C0) (b c)) c)) ================================================ FILE: tests/snapshots/compile_file_o_all__tagged_dup.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/tagged_dup.bend --- Errors: In tests/golden_tests/compile_file_o_all/tagged_dup.bend : - expected: '=' - detected:  4 | let #i {e f} = @x x; ================================================ FILE: tests/snapshots/compile_file_o_all__tagged_lam.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/tagged_lam.bend --- Errors: In tests/golden_tests/compile_file_o_all/tagged_lam.bend : - expected: term - detected: end of input  2 |   ================================================ FILE: tests/snapshots/compile_file_o_all__tagged_sup.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/tagged_sup.bend --- Errors: In tests/golden_tests/compile_file_o_all/tagged_sup.bend : - expected: top-level definition - detected:  2 | b = #i {λx x λx x} ================================================ FILE: tests/snapshots/compile_file_o_all__unapplied_eta.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/unapplied_eta.bend --- @Id = (a a) @main = a & @Id ~ a ================================================ FILE: tests/snapshots/compile_file_o_all__unscoped_eta.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/unscoped_eta.bend --- @main = (a a) ================================================ FILE: tests/snapshots/compile_file_o_all__var_shadows_ref.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/var_shadows_ref.bend --- @a = (a a) @main = b & @a ~ ((a a) b) ================================================ FILE: tests/snapshots/compile_file_o_all__weekday.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_all/weekday.bend --- @Weekday/Saturday = ((5 a) a) @main = b & (a a) ~ (@Weekday/Saturday b) ================================================ FILE: tests/snapshots/compile_file_o_no_all__bitonic_sort.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_no_all/bitonic_sort.bend --- Errors: The following functions contain recursive cycles incompatible with HVM's strict evaluation: * Down -> Flow -> Down * Warp -> Warp * Gen -> Gen * Rev -> Rev * Sort -> Sort and 1 other cycles... The greedy eager evaluation of HVM may cause infinite loops. Refactor these functions to use lazy references instead of direct function calls. A reference is strict when it's being called ('(Foo x)') or when it's used non-linearly ('let x = Foo; (x x)'). It is lazy when it's an argument ('(x Foo)') or when it's used linearly ('let x = Foo; (x 0)'). Try one of these strategies: - Use pattern matching with 'match', 'fold', and 'bend' to automatically lift expressions to lazy references. - Replace direct calls with combinators. For example, change: 'Foo = λa λb (b (λc (Foo a c)) a)' to: 'Foo = λa λb (b (λc λa (Foo a c)) (λa a) a)' which is lifted to: 'Foo = λa λb (b Foo__C1 Foo__C2 a)' - Replace non-linear 'let' expressions with 'use' expressions. For example, change: 'Foo = λf let x = Foo; (f x x)' to: 'Foo = λf use x = Foo; (f x x)' which inlines to: 'Foo = λf (f Foo Foo)' - If disabled, re-enable the default 'float-combinators' and 'linearize-matches' compiler options. For more information, visit: https://github.com/HigherOrderCO/Bend/blob/main/docs/lazy-definitions.md. To disable this check, use the "-Arecursion-cycle" compiler option. ================================================ FILE: tests/snapshots/compile_file_o_no_all__list_reverse.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_no_all/list_reverse.bend --- Errors: The following functions contain recursive cycles incompatible with HVM's strict evaluation: * concat -> concat * reverse -> reverse The greedy eager evaluation of HVM may cause infinite loops. Refactor these functions to use lazy references instead of direct function calls. A reference is strict when it's being called ('(Foo x)') or when it's used non-linearly ('let x = Foo; (x x)'). It is lazy when it's an argument ('(x Foo)') or when it's used linearly ('let x = Foo; (x 0)'). Try one of these strategies: - Use pattern matching with 'match', 'fold', and 'bend' to automatically lift expressions to lazy references. - Replace direct calls with combinators. For example, change: 'Foo = λa λb (b (λc (Foo a c)) a)' to: 'Foo = λa λb (b (λc λa (Foo a c)) (λa a) a)' which is lifted to: 'Foo = λa λb (b Foo__C1 Foo__C2 a)' - Replace non-linear 'let' expressions with 'use' expressions. For example, change: 'Foo = λf let x = Foo; (f x x)' to: 'Foo = λf use x = Foo; (f x x)' which inlines to: 'Foo = λf (f Foo Foo)' - If disabled, re-enable the default 'float-combinators' and 'linearize-matches' compiler options. For more information, visit: https://github.com/HigherOrderCO/Bend/blob/main/docs/lazy-definitions.md. To disable this check, use the "-Arecursion-cycle" compiler option. ================================================ FILE: tests/snapshots/compile_file_o_no_all__redex_order.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_no_all/redex_order.bend --- @a = (a a) @b = (a a) @bar = i & @a ~ (d (h i)) & @b ~ (a (c d)) & @c ~ (0 a) & @c ~ (b c) & @d ~ (1 b) & @b ~ (f (g h)) & @c ~ (e f) & @d ~ (2 e) & @c ~ (3 g) @c = (a a) @d = (a a) @foo = (a d) & @a ~ (c d) & @b ~ (b c) & @c ~ (a b) @foo2 = c & @a ~ (b c) & @b ~ (a b) & @c ~ (0 a) @main = a & @foo ~ (@foo2 a) ================================================ FILE: tests/snapshots/compile_file_o_no_all__sum_tree.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_file_o_no_all/sum_tree.bend --- Errors: The following functions contain recursive cycles incompatible with HVM's strict evaluation: * gen -> gen * sum -> sum The greedy eager evaluation of HVM may cause infinite loops. Refactor these functions to use lazy references instead of direct function calls. A reference is strict when it's being called ('(Foo x)') or when it's used non-linearly ('let x = Foo; (x x)'). It is lazy when it's an argument ('(x Foo)') or when it's used linearly ('let x = Foo; (x 0)'). Try one of these strategies: - Use pattern matching with 'match', 'fold', and 'bend' to automatically lift expressions to lazy references. - Replace direct calls with combinators. For example, change: 'Foo = λa λb (b (λc (Foo a c)) a)' to: 'Foo = λa λb (b (λc λa (Foo a c)) (λa a) a)' which is lifted to: 'Foo = λa λb (b Foo__C1 Foo__C2 a)' - Replace non-linear 'let' expressions with 'use' expressions. For example, change: 'Foo = λf let x = Foo; (f x x)' to: 'Foo = λf use x = Foo; (f x x)' which inlines to: 'Foo = λf (f Foo Foo)' - If disabled, re-enable the default 'float-combinators' and 'linearize-matches' compiler options. For more information, visit: https://github.com/HigherOrderCO/Bend/blob/main/docs/lazy-definitions.md. To disable this check, use the "-Arecursion-cycle" compiler option. ================================================ FILE: tests/snapshots/compile_long__huge_tree.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_long/huge_tree.bend --- Errors: In definition 'main': Definition is too large for HVM C (size=120002, max size=4095). Please break it into smaller pieces. ================================================ FILE: tests/snapshots/compile_long__long_str_file.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/compile_long/long_str_file.bend --- Errors: In definition 'main': Definition is too large for HVM C (size=1461028, max size=4095). Please break it into smaller pieces. ================================================ FILE: tests/snapshots/desugar_file__ask_branch.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/desugar_file/ask_branch.bend --- IO/MAGIC: (u24, u24) (IO/MAGIC) = (13683217, 16719857) IO/wrap: (a -> (IO a)) (IO/wrap) = λa (IO/Done IO/MAGIC a) IO/bind: ((IO a) -> ((c -> c) -> a -> (IO b)) -> (IO b)) (IO/bind) = λa λb (a IO/bind__C2 b) undefer: (((a -> a) -> b) -> b) (undefer) = λa (a λb b) unchecked main: Any (main) = (IO/bind (Bool/T λa switch a { 0: (IO/wrap 0); _: λ* (IO/wrap 0); }) λb (b λc λd (c d) IO/wrap)) IO/Done/tag: u24 (IO/Done/tag) = 0 IO/Done: ((u24, u24) -> a -> (IO a)) (IO/Done) = λa λb λc (c IO/Done/tag a b) IO/Call/tag: u24 (IO/Call/tag) = 1 IO/Call: ((u24, u24) -> String -> Any -> ((Result Any (IOError Any)) -> (IO a)) -> (IO a)) (IO/Call) = λa λb λc λd λe (e IO/Call/tag a b c d) Bool/T/tag: u24 (Bool/T/tag) = 0 Bool/T: Bool (Bool/T) = λa (a Bool/T/tag) Bool/F/tag: u24 (Bool/F/tag) = 1 Bool/F: Bool (Bool/F) = λa (a Bool/F/tag) IO/bind__C0: _ (IO/bind__C0) = λ* λa λb (undefer b a) IO/bind__C1: _ (IO/bind__C1) = λ* λa λb λc λd λe (IO/Call a b c λf (IO/bind (d f) e)) IO/bind__C2: _ (IO/bind__C2) = λa switch a { 0: IO/bind__C0; _: IO/bind__C1; } ================================================ FILE: tests/snapshots/desugar_file__bind_syntax.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/desugar_file/bind_syntax.bend --- unchecked Result/bind: Any (Result/bind) = λa λb (a Result/bind__C2 b) unchecked safe_div: Any (safe_div) = λa λb (switch b { 0: λ* (Result/Err (String/Cons 68 (String/Cons 105 (String/Cons 118 (String/Cons 32 (String/Cons 98 (String/Cons 121 (String/Cons 32 (String/Cons 48 String/Nil))))))))); _: safe_div__C0; } a) unchecked safe_rem: Any (safe_rem) = λa λb (switch b { 0: λ* (Result/Err (String/Cons 77 (String/Cons 111 (String/Cons 100 (String/Cons 32 (String/Cons 98 (String/Cons 121 (String/Cons 32 (String/Cons 48 String/Nil))))))))); _: safe_rem__C0; } a) unchecked Main: Any (Main) = (Result/bind (safe_div 3 2) λa (a λb (Result/bind (safe_rem b 0) λc (c λd d)))) undefer: (((a -> a) -> b) -> b) (undefer) = λa (a λb b) String/Nil/tag: u24 (String/Nil/tag) = 0 String/Nil: String (String/Nil) = λa (a String/Nil/tag) String/Cons/tag: u24 (String/Cons/tag) = 1 String/Cons: (u24 -> String -> String) (String/Cons) = λa λb λc (c String/Cons/tag a b) Result/Ok/tag: u24 (Result/Ok/tag) = 0 Result/Ok: (b -> (Result b a)) (Result/Ok) = λa λb (b Result/Ok/tag a) Result/Err/tag: u24 (Result/Err/tag) = 1 Result/Err: (a -> (Result b a)) (Result/Err) = λa λb (b Result/Err/tag a) unchecked Result/bind__C0: _ (Result/bind__C0) = λa λb (undefer b a) unchecked Result/bind__C1: _ (Result/bind__C1) = λ* λa λ* (Result/Err a) unchecked Result/bind__C2: _ (Result/bind__C2) = λa switch a { 0: Result/bind__C0; _: Result/bind__C1; } unchecked safe_div__C0: _ (safe_div__C0) = λa λb (Result/Ok (/ b (+ a 1))) unchecked safe_rem__C0: _ (safe_rem__C0) = λa λb (Result/Ok (% b (+ a 1))) ================================================ FILE: tests/snapshots/desugar_file__combinators.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/desugar_file/combinators.bend --- unchecked foo: Any (foo) = λa λ* λ* (foo a) unchecked bar: Any (bar) = λa λb (a bar b) unchecked List/ignore: Any (List/ignore) = λa λ* (a List/ignore__C1) unchecked baz: Any (baz) = {0 1 2 3 λa a foo} unchecked qux: Any (qux) = {0 qux} unchecked clax: Any (clax) = (λa a clax__C0) unchecked tup: Any (tup) = (tup, 1, 0) unchecked list: Any (list) = (List/Cons 0 list__C0) unchecked A: Any (A) = λa (A__C0 a) unchecked B: Any (B) = λa (B__C0 a) unchecked Main: Any (Main) = (List/Cons 0 (List/Cons list List/Nil)) List/Nil/tag: u24 (List/Nil/tag) = 0 List/Nil: (List a) (List/Nil) = λa (a List/Nil/tag) List/Cons/tag: u24 (List/Cons/tag) = 1 List/Cons: (a -> (List a) -> (List a)) (List/Cons) = λa λb λc (c List/Cons/tag a b) unchecked A__C0: _ (A__C0) = let {a b} = A; λc (a b c) unchecked B__C0: _ (B__C0) = let (a, b) = B; λc (a b c) unchecked List/ignore__C0: _ (List/ignore__C0) = λ* λ* λa (List/ignore a List/ignore) unchecked List/ignore__C1: _ (List/ignore__C1) = λa switch a { 0: 0; _: List/ignore__C0; } unchecked clax__C0: _ (clax__C0) = λ* λ* λ* λa (clax a) unchecked list__C0: _ (list__C0) = (List/Cons list List/Nil) ================================================ FILE: tests/snapshots/desugar_file__deref_loop.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/desugar_file/deref_loop.bend --- unchecked foo: Any (foo) = λa (a foo__C1) unchecked bar: Any (bar) = (foo 1) unchecked main: Any (main) = (foo 0) nat/succ/tag: u24 (nat/succ/tag) = 0 nat/succ: (Any -> nat) (nat/succ) = λa λb (b nat/succ/tag a) nat/zero/tag: u24 (nat/zero/tag) = 1 nat/zero: nat (nat/zero) = λa (a nat/zero/tag) unchecked foo__C0: _ (foo__C0) = λ* (bar 0) unchecked foo__C1: _ (foo__C1) = λa switch a { 0: λb b; _: foo__C0; } ================================================ FILE: tests/snapshots/desugar_file__dup_linearization.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/desugar_file/dup_linearization.bend --- unchecked main: Any (main) = let {a b c d e} = *; (a, e, d, c, b) ================================================ FILE: tests/snapshots/desugar_file__local_def_shadow.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/desugar_file/local_def_shadow.bend --- unchecked main: Any (main) = 1 unchecked main__local_0_A__local_0_B: _ (main__local_0_A__local_0_B) = 0 unchecked main__local_1_A__local_1_B: _ (main__local_1_A__local_1_B) = 1 unchecked main__local_1_A: _ (main__local_1_A) = main__local_1_A__local_1_B unchecked main__local_0_A: _ (main__local_0_A) = main__local_0_A__local_0_B ================================================ FILE: tests/snapshots/desugar_file__main_aux.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/desugar_file/main_aux.bend --- unchecked main: Any (main) = (main__local_0_aux 89 2) unchecked main__local_0_aux__local_0_aux__local_0_aux: _ (main__local_0_aux__local_0_aux__local_0_aux) = λa λb (+ b a) unchecked main__local_0_aux__local_0_aux: _ (main__local_0_aux__local_0_aux) = λa λb (main__local_0_aux__local_0_aux__local_0_aux a b) unchecked main__local_0_aux: _ (main__local_0_aux) = λa λb (main__local_0_aux__local_0_aux a b) ================================================ FILE: tests/snapshots/desugar_file__mapper_syntax.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/desugar_file/mapper_syntax.bend --- Maybe/unwrap: ((Maybe a) -> a) (Maybe/unwrap) = λa (a Maybe/unwrap__C0) Map/empty: (Map a) (Map/empty) = Map/Leaf Map/get: ((Map a) -> u24 -> (a, (Map a))) (Map/get) = λa λb (a Map/get__C5 b) Map/set: ((Map a) -> u24 -> a -> (Map a)) (Map/set) = λa λb λc (a Map/set__C10 b c) Map/map: ((Map a) -> u24 -> (a -> a) -> (Map a)) (Map/map) = λa λb λc (a Map/map__C5 b c) unreachable: Any (unreachable) = * unchecked main: Any (main) = let (c, d) = (Map/get (Map/map (Map/map (Map/set (Map/set Map/empty 0 3) 1 4) 1 λa (+ a 1)) 1 λb (* b 2)) 1); let (e, *) = (Map/get d 0); ((λf (+ f 1) 1), c, e) Maybe/Some/tag: u24 (Maybe/Some/tag) = 0 Maybe/Some: (a -> (Maybe a)) (Maybe/Some) = λa λb (b Maybe/Some/tag a) Maybe/None/tag: u24 (Maybe/None/tag) = 1 Maybe/None: (Maybe a) (Maybe/None) = λa (a Maybe/None/tag) Map/Node/tag: u24 (Map/Node/tag) = 0 Map/Node: ((Maybe a) -> (Map a) -> (Map a) -> (Map a)) (Map/Node) = λa λb λc λd (d Map/Node/tag a b c) Map/Leaf/tag: u24 (Map/Leaf/tag) = 1 Map/Leaf: (Map a) (Map/Leaf) = λa (a Map/Leaf/tag) Map/get__C0: _ (Map/get__C0) = λa λb λc λd let (e, f) = (Map/get d (/ a 2)); (e, (Map/Node b c f)) Map/get__C1: _ (Map/get__C1) = λ* λa λb λc λd let (e, f) = (Map/get c (/ a 2)); (e, (Map/Node b f d)) Map/get__C2: _ (Map/get__C2) = λa let {b c} = a; λd λe λf (switch (== (% b 2) 0) { 0: Map/get__C0; _: Map/get__C1; } c d e f) Map/get__C3: _ (Map/get__C3) = λ* λ* λa let {b c} = a; λd λe ((Maybe/unwrap b), (Map/Node c d e)) Map/get__C4: _ (Map/get__C4) = λa λb λc λd let {e f} = d; (switch (== 0 e) { 0: Map/get__C2; _: Map/get__C3; } f a b c) Map/get__C5: _ (Map/get__C5) = λa switch a { 0: Map/get__C4; _: λ* λ* (unreachable, Map/Leaf); } Map/map__C0: _ (Map/map__C0) = λa λb λc λd λe (Map/Node c d (Map/map e (/ a 2) b)) Map/map__C1: _ (Map/map__C1) = λ* λa λb λc λd λe (Map/Node c (Map/map d (/ a 2) b) e) Map/map__C2: _ (Map/map__C2) = λa let {b c} = a; λd λe λf λg (switch (== (% b 2) 0) { 0: Map/map__C0; _: Map/map__C1; } c d e f g) Map/map__C3: _ (Map/map__C3) = λ* λ* λa λb λc λd (Map/Node (Maybe/Some (a (Maybe/unwrap b))) c d) Map/map__C4: _ (Map/map__C4) = λa λb λc λd let {e f} = d; λg (switch (== 0 e) { 0: Map/map__C2; _: Map/map__C3; } f g a b c) Map/map__C5: _ (Map/map__C5) = λa switch a { 0: Map/map__C4; _: λ* λ* λ* Map/Leaf; } Map/set__C0: _ (Map/set__C0) = λa λb λc λd λe (Map/Node c d (Map/set e (/ a 2) b)) Map/set__C1: _ (Map/set__C1) = λ* λa λb λc λd λe (Map/Node c (Map/set d (/ a 2) b) e) Map/set__C10: _ (Map/set__C10) = λa switch a { 0: Map/set__C8; _: Map/set__C9; } Map/set__C2: _ (Map/set__C2) = λa let {b c} = a; λd λe λf λg (switch (== (% b 2) 0) { 0: Map/set__C0; _: Map/set__C1; } c d e f g) Map/set__C3: _ (Map/set__C3) = λ* λ* λa λ* λb λc (Map/Node (Maybe/Some a) b c) Map/set__C4: _ (Map/set__C4) = λa λb (Map/Node Maybe/None Map/Leaf (Map/set Map/Leaf (/ a 2) b)) Map/set__C5: _ (Map/set__C5) = λ* λa λb (Map/Node Maybe/None (Map/set Map/Leaf (/ a 2) b) Map/Leaf) Map/set__C6: _ (Map/set__C6) = λa let {b c} = a; λd (switch (== (% b 2) 0) { 0: Map/set__C4; _: Map/set__C5; } c d) Map/set__C7: _ (Map/set__C7) = λ* λ* λa (Map/Node (Maybe/Some a) Map/Leaf Map/Leaf) Map/set__C8: _ (Map/set__C8) = λa λb λc λd let {e f} = d; λg (switch (== 0 e) { 0: Map/set__C2; _: Map/set__C3; } f g a b c) Map/set__C9: _ (Map/set__C9) = λ* λa let {b c} = a; λd (switch (== 0 b) { 0: Map/set__C6; _: Map/set__C7; } c d) Maybe/unwrap__C0: _ (Maybe/unwrap__C0) = λa switch a { 0: λb b; _: λ* unreachable; } ================================================ FILE: tests/snapshots/desugar_file__switch_with_use.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/desugar_file/switch_with_use.bend --- unchecked main: Any (main) = λa λb λc λ* λ* (switch c { 0: λd d; _: λe λf (e f); } (a b)) ================================================ FILE: tests/snapshots/desugar_file__tree_syntax.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/desugar_file/tree_syntax.bend --- unchecked fun0: Any (fun0) = (Tree/Node (Tree/Leaf 0) (Tree/Node (Tree/Leaf 1) (Tree/Node (Tree/Leaf 2) (Tree/Leaf 3)))) unchecked fun1: Any (fun1) = (Tree/Leaf (Tree/Node (Tree/Leaf *) (Tree/Leaf *))) unchecked fun2: Any (fun2) = (Tree/Leaf (Tree/Leaf (Tree/Leaf *))) unchecked fun3: Any (fun3) = (Tree/Leaf 1) unchecked fun4: Any (fun4) = λa switch a { 0: (Tree/Leaf 0); _: fun4__C0; } unchecked main: Any (main) = * unchecked imp0: Any (imp0) = (Tree/Node (Tree/Leaf 0) (Tree/Node (Tree/Leaf 1) (Tree/Node (Tree/Leaf 2) (Tree/Leaf 3)))) unchecked imp1: Any (imp1) = (Tree/Leaf (Tree/Node (Tree/Leaf *) (Tree/Leaf *))) unchecked imp2: Any (imp2) = (Tree/Leaf (Tree/Leaf (Tree/Leaf *))) unchecked imp3: Any (imp3) = (Tree/Leaf 1) unchecked imp4: (Any -> Any) (imp4) = λa switch a { 0: (Tree/Leaf 0); _: imp4__C0; } Tree/Node/tag: u24 (Tree/Node/tag) = 0 Tree/Node: ((Tree a) -> (Tree a) -> (Tree a)) (Tree/Node) = λa λb λc (c Tree/Node/tag a b) Tree/Leaf/tag: u24 (Tree/Leaf/tag) = 1 Tree/Leaf: (a -> (Tree a)) (Tree/Leaf) = λa λb (b Tree/Leaf/tag a) unchecked fun4__C0: _ (fun4__C0) = λa let {b c} = a; (Tree/Node (fun4 b) (fun4 c)) unchecked imp4__C0: _ (imp4__C0) = λa let {b c} = a; (Tree/Node (imp4 b) (imp4 c)) ================================================ FILE: tests/snapshots/desugar_file__use_id.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/desugar_file/use_id.bend --- unchecked Main: Any (Main) = (λa a 2 3 (λb b 2 3) (λc c 2 3 (λd d 2 3))) ================================================ FILE: tests/snapshots/desugar_file__use_shadow.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/desugar_file/use_shadow.bend --- unchecked main: Any (main) = λa let {b c} = a; λd (b c d) ================================================ FILE: tests/snapshots/desugar_file__used_once_names.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/desugar_file/used_once_names.bend --- unchecked foo: Any (foo) = λa λb λc let {d e} = c; (a b (d e)) unchecked main: Any (main) = (foo 2 3 λa a) ================================================ FILE: tests/snapshots/encode_pattern_match__adt_tup_era.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/adt_tup_era.bend --- Scott unchecked Foo: Any (Foo) = λa (a λb λc (b λd λ* λ* d c)) unchecked Main: Any (Main) = (Foo (Tuple/Pair 1 5)) Tuple/Pair: (Any -> Any -> Tuple) (Tuple/Pair) = λa λb λc (c a b) NumScott unchecked Foo: Any (Foo) = λa (a λb switch b { 0: λc λd (c λe switch e { 0: λf λ* λ* f; _: *; } d); _: *; }) unchecked Main: Any (Main) = (Foo (Tuple/Pair 1 5)) Tuple/Pair/tag: _ (Tuple/Pair/tag) = 0 Tuple/Pair: (Any -> Any -> Tuple) (Tuple/Pair) = λa λb λc (c Tuple/Pair/tag a b) ================================================ FILE: tests/snapshots/encode_pattern_match__and3.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/and3.bend --- Scott unchecked And: Any (And) = λa let (b, c, d) = a; (b λe λf (e λg (g Bool/T Bool/F) λ* Bool/F f) λ* λ* Bool/F c d) unchecked main: Any (main) = (And (Bool/F, Bool/T, Bool/F)) Bool/T: Bool (Bool/T) = λa λ* a Bool/F: Bool (Bool/F) = λ* λb b NumScott unchecked And: Any (And) = λa let (b, c, d) = a; (b λe switch e { 0: λf λg (f λh switch h { 0: λi (i λj switch j { 0: Bool/T; _: λ* Bool/F; }); _: λ* λ* Bool/F; } g); _: λ* λ* λ* Bool/F; } c d) unchecked main: Any (main) = (And (Bool/F, Bool/T, Bool/F)) Bool/T/tag: _ (Bool/T/tag) = 0 Bool/T: Bool (Bool/T) = λa (a Bool/T/tag) Bool/F/tag: _ (Bool/F/tag) = 1 Bool/F: Bool (Bool/F) = λa (a Bool/F/tag) ================================================ FILE: tests/snapshots/encode_pattern_match__bool.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/bool.bend --- Scott unchecked not: Any (not) = λa (a bool/false bool/true) unchecked and: Any (and) = λa (a λb (b bool/true bool/false) λd (d bool/false bool/false)) unchecked and2: Any (and2) = λa (a λb b λd let * = d; bool/false) unchecked and3: Any (and3) = λa (a λb (b bool/true bool/false) λd let * = d; bool/false) unchecked and4: Any (and4) = λa (a λb (b bool/true bool/false) λd let * = d; bool/false) bool/true: bool (bool/true) = λa λ* a bool/false: bool (bool/false) = λ* λb b NumScott unchecked not: Any (not) = λa (a λb switch b { 0: bool/false; _: λ* bool/true; }) unchecked and: Any (and) = λa (a λb switch b { 0: λc (c λe switch e { 0: bool/true; _: λ* bool/false; }); _: λ* λf (f λh switch h { 0: bool/false; _: λ* bool/false; }); }) unchecked and2: Any (and2) = λa (a λb switch b { 0: λc c; _: λ* λe let * = e; bool/false; }) unchecked and3: Any (and3) = λa (a λb switch b { 0: λc (c λe switch e { 0: bool/true; _: λ* bool/false; }); _: λ* λf let * = f; bool/false; }) unchecked and4: Any (and4) = λa (a λb switch b { 0: λc (c λe switch e { 0: bool/true; _: λ* bool/false; }); _: λ* λf let * = f; bool/false; }) bool/true/tag: _ (bool/true/tag) = 0 bool/true: bool (bool/true) = λa (a bool/true/tag) bool/false/tag: _ (bool/false/tag) = 1 bool/false: bool (bool/false) = λa (a bool/false/tag) ================================================ FILE: tests/snapshots/encode_pattern_match__bool_tup.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/bool_tup.bend --- Scott unchecked foo: Any (foo) = λa let (b, c) = a; (b λd d λ* Bool/F c) unchecked main: Any (main) = (foo (Bool/F, Bool/T)) Bool/T: Bool (Bool/T) = λa λ* a Bool/F: Bool (Bool/F) = λ* λb b NumScott unchecked foo: Any (foo) = λa let (b, c) = a; (b λd switch d { 0: λe e; _: λ* λ* Bool/F; } c) unchecked main: Any (main) = (foo (Bool/F, Bool/T)) Bool/T/tag: _ (Bool/T/tag) = 0 Bool/T: Bool (Bool/T) = λa (a Bool/T/tag) Bool/F/tag: _ (Bool/F/tag) = 1 Bool/F: Bool (Bool/F) = λa (a Bool/F/tag) ================================================ FILE: tests/snapshots/encode_pattern_match__box.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/box.bend --- Scott unchecked unbox: Any (unbox) = λa (a λb b) box/new: (Any -> box) (box/new) = λa λb (b a) NumScott unchecked unbox: Any (unbox) = λa (a λb switch b { 0: λc c; _: *; }) box/new/tag: _ (box/new/tag) = 0 box/new: (Any -> box) (box/new) = λa λb (b box/new/tag a) ================================================ FILE: tests/snapshots/encode_pattern_match__common.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/common.bend --- Scott Box/Filled: (Any -> Box) (Box/Filled) = λa λb λ* (b a) Box/Empty: Box (Box/Empty) = λ* λb b Option/Some: (Any -> Option) (Option/Some) = λa λb λ* (b a) Option/None: Option (Option/None) = λ* λb b Result_/Ok: (Any -> Result_) (Result_/Ok) = λa λb λ* (b a) Result_/Err: (Any -> Result_) (Result_/Err) = λa λ* λc (c a) List_/Cons: (Any -> Any -> List_) (List_/Cons) = λa λb λc λ* (c a b) List_/Nil: List_ (List_/Nil) = λ* λb b Bool/True: Bool (Bool/True) = λa λ* a Bool/False: Bool (Bool/False) = λ* λb b Light/Red: Light (Light/Red) = λa λ* λ* a Light/Yellow: Light (Light/Yellow) = λ* λb λ* b Light/Green: Light (Light/Green) = λ* λ* λc c Direction/North: Direction (Direction/North) = λa λ* λ* λ* a Direction/South: Direction (Direction/South) = λ* λb λ* λ* b Direction/East: Direction (Direction/East) = λ* λ* λc λ* c Direction/West: Direction (Direction/West) = λ* λ* λ* λd d NumScott Box/Filled/tag: _ (Box/Filled/tag) = 0 Box/Filled: (Any -> Box) (Box/Filled) = λa λb (b Box/Filled/tag a) Box/Empty/tag: _ (Box/Empty/tag) = 1 Box/Empty: Box (Box/Empty) = λa (a Box/Empty/tag) Option/Some/tag: _ (Option/Some/tag) = 0 Option/Some: (Any -> Option) (Option/Some) = λa λb (b Option/Some/tag a) Option/None/tag: _ (Option/None/tag) = 1 Option/None: Option (Option/None) = λa (a Option/None/tag) Result_/Ok/tag: _ (Result_/Ok/tag) = 0 Result_/Ok: (Any -> Result_) (Result_/Ok) = λa λb (b Result_/Ok/tag a) Result_/Err/tag: _ (Result_/Err/tag) = 1 Result_/Err: (Any -> Result_) (Result_/Err) = λa λb (b Result_/Err/tag a) List_/Cons/tag: _ (List_/Cons/tag) = 0 List_/Cons: (Any -> Any -> List_) (List_/Cons) = λa λb λc (c List_/Cons/tag a b) List_/Nil/tag: _ (List_/Nil/tag) = 1 List_/Nil: List_ (List_/Nil) = λa (a List_/Nil/tag) Bool/True/tag: _ (Bool/True/tag) = 0 Bool/True: Bool (Bool/True) = λa (a Bool/True/tag) Bool/False/tag: _ (Bool/False/tag) = 1 Bool/False: Bool (Bool/False) = λa (a Bool/False/tag) Light/Red/tag: _ (Light/Red/tag) = 0 Light/Red: Light (Light/Red) = λa (a Light/Red/tag) Light/Yellow/tag: _ (Light/Yellow/tag) = 1 Light/Yellow: Light (Light/Yellow) = λa (a Light/Yellow/tag) Light/Green/tag: _ (Light/Green/tag) = 2 Light/Green: Light (Light/Green) = λa (a Light/Green/tag) Direction/North/tag: _ (Direction/North/tag) = 0 Direction/North: Direction (Direction/North) = λa (a Direction/North/tag) Direction/South/tag: _ (Direction/South/tag) = 1 Direction/South: Direction (Direction/South) = λa (a Direction/South/tag) Direction/East/tag: _ (Direction/East/tag) = 2 Direction/East: Direction (Direction/East) = λa (a Direction/East/tag) Direction/West/tag: _ (Direction/West/tag) = 3 Direction/West: Direction (Direction/West) = λa (a Direction/West/tag) ================================================ FILE: tests/snapshots/encode_pattern_match__concat.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/concat.bend --- Scott unchecked String/concat: Any (String/concat) = λ* λb b unchecked main: Any (main) = (String/concat (String/Cons 97 (String/Cons 98 String/Nil)) (String/Cons 99 (String/Cons 100 String/Nil))) String/Nil: String (String/Nil) = λa λ* a String/Cons: (u24 -> String -> String) (String/Cons) = λa λb λ* λd (d a b) NumScott unchecked String/concat: Any (String/concat) = λ* λb b unchecked main: Any (main) = (String/concat (String/Cons 97 (String/Cons 98 String/Nil)) (String/Cons 99 (String/Cons 100 String/Nil))) String/Nil/tag: _ (String/Nil/tag) = 0 String/Nil: String (String/Nil) = λa (a String/Nil/tag) String/Cons/tag: _ (String/Cons/tag) = 1 String/Cons: (u24 -> String -> String) (String/Cons) = λa λb λc (c String/Cons/tag a b) ================================================ FILE: tests/snapshots/encode_pattern_match__concat_def.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/concat_def.bend --- Scott unchecked concat: Any (concat) = λa (a λb b λd λe λf (String/Cons d (concat e f))) unchecked main: Any (main) = (concat (String/Cons 97 (String/Cons 98 String/Nil)) (String/Cons 99 (String/Cons 100 String/Nil))) String/Nil: String (String/Nil) = λa λ* a String/Cons: (u24 -> String -> String) (String/Cons) = λa λb λ* λd (d a b) NumScott unchecked concat: Any (concat) = λa (a λb switch b { 0: λc c; _: λ* λe λf λg (String/Cons e (concat f g)); }) unchecked main: Any (main) = (concat (String/Cons 97 (String/Cons 98 String/Nil)) (String/Cons 99 (String/Cons 100 String/Nil))) String/Nil/tag: _ (String/Nil/tag) = 0 String/Nil: String (String/Nil) = λa (a String/Nil/tag) String/Cons/tag: _ (String/Cons/tag) = 1 String/Cons: (u24 -> String -> String) (String/Cons) = λa λb λc (c String/Cons/tag a b) ================================================ FILE: tests/snapshots/encode_pattern_match__def_tups.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/def_tups.bend --- Scott unchecked go: Any (go) = λa let (b, c) = a; let (d, e) = c; let (f, g) = e; let (h, i) = g; (+ (+ (+ (+ i h) f) d) b) unchecked main: Any (main) = (go (1, (2, (3, (4, 5))))) NumScott unchecked go: Any (go) = λa let (b, c) = a; let (d, e) = c; let (f, g) = e; let (h, i) = g; (+ (+ (+ (+ i h) f) d) b) unchecked main: Any (main) = (go (1, (2, (3, (4, 5))))) ================================================ FILE: tests/snapshots/encode_pattern_match__definition_merge.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/definition_merge.bend --- Scott unchecked Foo: Any (Foo) = λa (a λb (b λc (c λf (f 1 1) λg (g 2 2)) λh (h λk (k 1 1) λl (l 2 2))) λm (m λn (n λq (q 3 3) λr (r 3 3)) λs (s λv (v 3 3) λw (w 3 3)))) Either/Left: (Any -> Either) (Either/Left) = λa λb λ* (b a) Either/Right: (Any -> Either) (Either/Right) = λa λ* λc (c a) Bool/True: Bool (Bool/True) = λa λ* a Bool/False: Bool (Bool/False) = λ* λb b NumScott unchecked Foo: Any (Foo) = λa (a λb switch b { 0: λc (c λd switch d { 0: λe (e λh switch h { 0: λi (i λj switch j { 0: 1; _: λ* 1; }); _: λ* λk (k λl switch l { 0: 2; _: λ* 2; }); }); _: λ* λm (m λp switch p { 0: λq (q λr switch r { 0: 1; _: λ* 1; }); _: λ* λs (s λt switch t { 0: 2; _: λ* 2; }); }); }); _: λ* λu (u λv switch v { 0: λw (w λz switch z { 0: λab (ab λbb switch bb { 0: 3; _: λ* 3; }); _: λ* λcb (cb λdb switch db { 0: 3; _: λ* 3; }); }); _: λ* λeb (eb λhb switch hb { 0: λib (ib λjb switch jb { 0: 3; _: λ* 3; }); _: λ* λkb (kb λlb switch lb { 0: 3; _: λ* 3; }); }); }); }) Either/Left/tag: _ (Either/Left/tag) = 0 Either/Left: (Any -> Either) (Either/Left) = λa λb (b Either/Left/tag a) Either/Right/tag: _ (Either/Right/tag) = 1 Either/Right: (Any -> Either) (Either/Right) = λa λb (b Either/Right/tag a) Bool/True/tag: _ (Bool/True/tag) = 0 Bool/True: Bool (Bool/True) = λa (a Bool/True/tag) Bool/False/tag: _ (Bool/False/tag) = 1 Bool/False: Bool (Bool/False) = λa (a Bool/False/tag) ================================================ FILE: tests/snapshots/encode_pattern_match__expr.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/expr.bend --- Scott Expr/Var: (Any -> Expr) (Expr/Var) = λa λb λ* λ* λ* λ* λ* λ* λ* λ* (b a) Expr/Num: (Any -> Expr) (Expr/Num) = λa λ* λc λ* λ* λ* λ* λ* λ* λ* (c a) Expr/App: (Any -> Any -> Expr) (Expr/App) = λa λb λ* λ* λe λ* λ* λ* λ* λ* λ* (e a b) Expr/Fun: (Any -> Any -> Expr) (Expr/Fun) = λa λb λ* λ* λ* λf λ* λ* λ* λ* λ* (f a b) Expr/If: (Any -> Any -> Any -> Expr) (Expr/If) = λa λb λc λ* λ* λ* λ* λh λ* λ* λ* λ* (h a b c) Expr/Let: (Any -> Any -> Any -> Expr) (Expr/Let) = λa λb λc λ* λ* λ* λ* λ* λi λ* λ* λ* (i a b c) Expr/Dup: (Any -> Any -> Any -> Any -> Expr) (Expr/Dup) = λa λb λc λd λ* λ* λ* λ* λ* λ* λk λ* λ* (k a b c d) Expr/Tup: (Any -> Any -> Expr) (Expr/Tup) = λa λb λ* λ* λ* λ* λ* λ* λ* λj λ* (j a b) Expr/Op2: (Any -> Any -> Any -> Expr) (Expr/Op2) = λa λb λc λ* λ* λ* λ* λ* λ* λ* λ* λl (l a b c) Op/Add: Op (Op/Add) = λa λ* λ* λ* a Op/Sub: Op (Op/Sub) = λ* λb λ* λ* b Op/Mul: Op (Op/Mul) = λ* λ* λc λ* c Op/Div: Op (Op/Div) = λ* λ* λ* λd d NumScott Expr/Var/tag: _ (Expr/Var/tag) = 0 Expr/Var: (Any -> Expr) (Expr/Var) = λa λb (b Expr/Var/tag a) Expr/Num/tag: _ (Expr/Num/tag) = 1 Expr/Num: (Any -> Expr) (Expr/Num) = λa λb (b Expr/Num/tag a) Expr/App/tag: _ (Expr/App/tag) = 2 Expr/App: (Any -> Any -> Expr) (Expr/App) = λa λb λc (c Expr/App/tag a b) Expr/Fun/tag: _ (Expr/Fun/tag) = 3 Expr/Fun: (Any -> Any -> Expr) (Expr/Fun) = λa λb λc (c Expr/Fun/tag a b) Expr/If/tag: _ (Expr/If/tag) = 4 Expr/If: (Any -> Any -> Any -> Expr) (Expr/If) = λa λb λc λd (d Expr/If/tag a b c) Expr/Let/tag: _ (Expr/Let/tag) = 5 Expr/Let: (Any -> Any -> Any -> Expr) (Expr/Let) = λa λb λc λd (d Expr/Let/tag a b c) Expr/Dup/tag: _ (Expr/Dup/tag) = 6 Expr/Dup: (Any -> Any -> Any -> Any -> Expr) (Expr/Dup) = λa λb λc λd λe (e Expr/Dup/tag a b c d) Expr/Tup/tag: _ (Expr/Tup/tag) = 7 Expr/Tup: (Any -> Any -> Expr) (Expr/Tup) = λa λb λc (c Expr/Tup/tag a b) Expr/Op2/tag: _ (Expr/Op2/tag) = 8 Expr/Op2: (Any -> Any -> Any -> Expr) (Expr/Op2) = λa λb λc λd (d Expr/Op2/tag a b c) Op/Add/tag: _ (Op/Add/tag) = 0 Op/Add: Op (Op/Add) = λa (a Op/Add/tag) Op/Sub/tag: _ (Op/Sub/tag) = 1 Op/Sub: Op (Op/Sub) = λa (a Op/Sub/tag) Op/Mul/tag: _ (Op/Mul/tag) = 2 Op/Mul: Op (Op/Mul) = λa (a Op/Mul/tag) Op/Div/tag: _ (Op/Div/tag) = 3 Op/Div: Op (Op/Div) = λa (a Op/Div/tag) ================================================ FILE: tests/snapshots/encode_pattern_match__flatten_era_pat.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/flatten_era_pat.bend --- Scott unchecked Fn1: Any (Fn1) = λa λ* let (*, d) = a; let (e, *) = d; e unchecked Fn2: Any (Fn2) = λa let (*, c) = a; let (*, e) = c; let (f, *) = e; f unchecked Fn3: Any (Fn3) = λa let (b, c) = a; (switch b { 0: λ* λe let * = e; 0; _: λg λ* λi let * = i; (+ g 1); } c) unchecked main: Any (main) = (Fn2 ((1, 2), (3, (4, (5, 6)))) 0) NumScott unchecked Fn1: Any (Fn1) = λa λ* let (*, d) = a; let (e, *) = d; e unchecked Fn2: Any (Fn2) = λa let (*, c) = a; let (*, e) = c; let (f, *) = e; f unchecked Fn3: Any (Fn3) = λa let (b, c) = a; (switch b { 0: λ* λe let * = e; 0; _: λg λ* λi let * = i; (+ g 1); } c) unchecked main: Any (main) = (Fn2 ((1, 2), (3, (4, (5, 6)))) 0) ================================================ FILE: tests/snapshots/encode_pattern_match__full_map.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/full_map.bend --- Scott Maybe/unwrap: ((Maybe T) -> T) (Maybe/unwrap) = λa (a λb b unreachable) Map/get: ((Map T) -> u24 -> (T, (Map T))) (Map/get) = λa (a λb let {b b_2 b_3 b_4} = b; λc let {c c_2 c_3} = c; λd let {d d_2 d_3} = d; λe let {e e_2 e_3 e_4} = e; switch (== 0 e) { 0: switch (== (% e_2 2) 0) { 0: let (f, g) = (Map/get d (/ e_3 2)); (f, (Map/Node b c g)); _: λ* let (i, j) = (Map/get c_2 (/ e_4 2)); (i, (Map/Node b_2 j d_2)); }; _: λ* ((Maybe/unwrap b_3), (Map/Node b_4 c_3 d_3)); } λ* (unreachable, Map/Leaf)) unreachable: Any (unreachable) = * unchecked prng: (Any -> Any) (prng) = λa let {a a_2} = a; let {b b_2} = (^ a (<< a_2 13)); let {c c_2} = (^ b (>> b_2 17)); (^ c (<< c_2 5)) unchecked fullMap: Any (fullMap) = (fullMap__bend0 14) unchecked test: (Any -> Any) (test) = λa (test__bend0 0 a) unchecked main: Any (main) = (test fullMap) Map/Node: ((Maybe T) -> (Map T) -> (Map T) -> (Map T)) (Map/Node) = λa λb λc λd λ* (d a b c) Map/Leaf: (Map T) (Map/Leaf) = λ* λb b unchecked fullMap__bend0: _ (fullMap__bend0) = λa let {a a_2 a_3} = a; switch (> a 0) { 0: Map/Leaf; _: λ* (Map/Node 1 (fullMap__bend0 (- a_2 1)) (fullMap__bend0 (- a_3 1))); } unchecked test__bend0: _ (test__bend0) = λa let {a a_2 a_3} = a; switch (< a 1000) { 0: λ* 0; _: λ* λd let (e, f) = (Map/get d (% (prng a_2) 4096)); (+ e (test__bend0 (+ a_3 1) f)); } NumScott Maybe/unwrap: ((Maybe T) -> T) (Maybe/unwrap) = λa (a λb switch b { 0: λc c; _: λ* unreachable; }) Map/get: ((Map T) -> u24 -> (T, (Map T))) (Map/get) = λa (a λb switch b { 0: λc let {c c_2 c_3 c_4} = c; λd let {d d_2 d_3} = d; λe let {e e_2 e_3} = e; λf let {f f_2 f_3 f_4} = f; switch (== 0 f) { 0: switch (== (% f_2 2) 0) { 0: let (g, h) = (Map/get e (/ f_3 2)); (g, (Map/Node c d h)); _: λ* let (j, k) = (Map/get d_2 (/ f_4 2)); (j, (Map/Node c_2 k e_2)); }; _: λ* ((Maybe/unwrap c_3), (Map/Node c_4 d_3 e_3)); }; _: λ* λ* (unreachable, Map/Leaf); }) unreachable: Any (unreachable) = * unchecked prng: (Any -> Any) (prng) = λa let {a a_2} = a; let {b b_2} = (^ a (<< a_2 13)); let {c c_2} = (^ b (>> b_2 17)); (^ c (<< c_2 5)) unchecked fullMap: Any (fullMap) = (fullMap__bend0 14) unchecked test: (Any -> Any) (test) = λa (test__bend0 0 a) unchecked main: Any (main) = (test fullMap) Map/Node/tag: _ (Map/Node/tag) = 0 Map/Node: ((Maybe T) -> (Map T) -> (Map T) -> (Map T)) (Map/Node) = λa λb λc λd (d Map/Node/tag a b c) Map/Leaf/tag: _ (Map/Leaf/tag) = 1 Map/Leaf: (Map T) (Map/Leaf) = λa (a Map/Leaf/tag) unchecked fullMap__bend0: _ (fullMap__bend0) = λa let {a a_2 a_3} = a; switch (> a 0) { 0: Map/Leaf; _: λ* (Map/Node 1 (fullMap__bend0 (- a_2 1)) (fullMap__bend0 (- a_3 1))); } unchecked test__bend0: _ (test__bend0) = λa let {a a_2 a_3} = a; switch (< a 1000) { 0: λ* 0; _: λ* λd let (e, f) = (Map/get d (% (prng a_2) 4096)); (+ e (test__bend0 (+ a_3 1) f)); } ================================================ FILE: tests/snapshots/encode_pattern_match__is_some_some.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/is_some_some.bend --- Scott unchecked some_some: Any (some_some) = λa (a λb (b λ* 1 0) 0) unchecked main: Any (main) = (some_some (Option/Some 1)) Option/Some: (Any -> Option) (Option/Some) = λa λb λ* (b a) Option/None: Option (Option/None) = λ* λb b NumScott unchecked some_some: Any (some_some) = λa (a λb switch b { 0: λc (c λd switch d { 0: λ* 1; _: λ* 0; }); _: λ* 0; }) unchecked main: Any (main) = (some_some (Option/Some 1)) Option/Some/tag: _ (Option/Some/tag) = 0 Option/Some: (Any -> Option) (Option/Some) = λa λb (b Option/Some/tag a) Option/None/tag: _ (Option/None/tag) = 1 Option/None: Option (Option/None) = λa (a Option/None/tag) ================================================ FILE: tests/snapshots/encode_pattern_match__list_merge_sort.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/list_merge_sort.bend --- Scott unchecked If: Any (If) = λa (a λb λc let * = c; b λf λg let * = f; g) unchecked Pure: Any (Pure) = λa (List_/Cons a List_/Nil) unchecked Map: Any (Map) = λa (a λb λc λd let {e e_2} = d; (List_/Cons (e b) (Map c e_2)) λf let * = f; List_/Nil) unchecked MergeSort: Any (MergeSort) = λa λb (Unpack a (Map b Pure)) unchecked Unpack: Any (Unpack) = λa λb (b λc λd λe (d λf λg λh let {h h_2} = h; λi (Unpack h (MergePair h_2 (List_/Cons i (List_/Cons f g)))) λ* λk k e c) λ* List_/Nil a) unchecked MergePair: Any (MergePair) = λa λb (b λc λd λe (d λf λg λh let {h h_2} = h; λi (List_/Cons (Merge h i f) (MergePair h_2 g)) λ* λk (List_/Cons k List_/Nil) e c) λ* List_/Nil a) unchecked Merge: Any (Merge) = λa λb (b λc λd λe λf (f λh let {h h_2 h_3} = h; λi let {i i_2} = i; λj let {j j_2 j_3} = j; λk let {k k_2 k_3} = k; λl let {l l_2} = l; (If (j k h) (List_/Cons k_2 (Merge j_2 l (List_/Cons h_2 i))) (List_/Cons h_3 (Merge j_3 (List_/Cons k_3 l_2) i_2))) λ* λp λq (List_/Cons p q) e c d) λ* λs s a) Bool/True: Bool (Bool/True) = λa λ* a Bool/False: Bool (Bool/False) = λ* λb b List_/Cons: (Any -> Any -> List_) (List_/Cons) = λa λb λc λ* (c a b) List_/Nil: List_ (List_/Nil) = λ* λb b NumScott unchecked If: Any (If) = λa (a λb switch b { 0: λc λd let * = d; c; _: λ* λg λh let * = g; h; }) unchecked Pure: Any (Pure) = λa (List_/Cons a List_/Nil) unchecked Map: Any (Map) = λa (a λb switch b { 0: λc λd λe let {f f_2} = e; (List_/Cons (f c) (Map d f_2)); _: λ* λg let * = g; List_/Nil; }) unchecked MergeSort: Any (MergeSort) = λa λb (Unpack a (Map b Pure)) unchecked Unpack: Any (Unpack) = λa λb (b λc switch c { 0: λd λe λf (e λg switch g { 0: λh λi λj let {j j_2} = j; λk (Unpack j (MergePair j_2 (List_/Cons k (List_/Cons h i)))); _: λ* λ* λm m; } f d); _: λ* λ* List_/Nil; } a) unchecked MergePair: Any (MergePair) = λa λb (b λc switch c { 0: λd λe λf (e λg switch g { 0: λh λi λj let {j j_2} = j; λk (List_/Cons (Merge j k h) (MergePair j_2 i)); _: λ* λ* λm (List_/Cons m List_/Nil); } f d); _: λ* λ* List_/Nil; } a) unchecked Merge: Any (Merge) = λa λb (b λc switch c { 0: λd λe λf λg (g λi switch i { 0: λj let {j j_2 j_3} = j; λk let {k k_2} = k; λl let {l l_2 l_3} = l; λm let {m m_2 m_3} = m; λn let {n n_2} = n; (If (l m j) (List_/Cons m_2 (Merge l_2 n (List_/Cons j_2 k))) (List_/Cons j_3 (Merge l_3 (List_/Cons m_3 n_2) k_2))); _: λ* λ* λr λs (List_/Cons r s); } f d e); _: λ* λ* λu u; } a) Bool/True/tag: _ (Bool/True/tag) = 0 Bool/True: Bool (Bool/True) = λa (a Bool/True/tag) Bool/False/tag: _ (Bool/False/tag) = 1 Bool/False: Bool (Bool/False) = λa (a Bool/False/tag) List_/Cons/tag: _ (List_/Cons/tag) = 0 List_/Cons: (Any -> Any -> List_) (List_/Cons) = λa λb λc (c List_/Cons/tag a b) List_/Nil/tag: _ (List_/Nil/tag) = 1 List_/Nil: List_ (List_/Nil) = λa (a List_/Nil/tag) ================================================ FILE: tests/snapshots/encode_pattern_match__list_str_encoding_undeclared_fn.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/list_str_encoding_undeclared_fn.bend --- Scott unchecked main: Any (main) = * unchecked Foo: Any (Foo) = λa (a 0 λ* λ* 1) unchecked Bar: Any (Bar) = λa (a 1 λ* λ* 0) NumScott unchecked main: Any (main) = * unchecked Foo: Any (Foo) = λa (a λb switch b { 0: 0; _: λ* λ* λ* 1; }) unchecked Bar: Any (Bar) = λa (a λb switch b { 0: 1; _: λ* λ* λ* 0; }) ================================================ FILE: tests/snapshots/encode_pattern_match__list_str_encoding_undeclared_map.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/list_str_encoding_undeclared_map.bend --- Scott unchecked main: Any (main) = λa λb ((a 2 λ* λ* 1), (b 2 λ* λ* 1)) NumScott unchecked main: Any (main) = λa λb ((a λc switch c { 0: 2; _: λ* λ* λ* 1; }), (b λg switch g { 0: 2; _: λ* λ* λ* 1; })) ================================================ FILE: tests/snapshots/encode_pattern_match__match_adt_unscoped_in_arm.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/match_adt_unscoped_in_arm.bend --- Scott unchecked main: Any (main) = λ* λ$x $x bool/T: bool (bool/T) = λa λ* a bool/F: bool (bool/F) = λ* λb b NumScott unchecked main: Any (main) = λ* λ$x $x bool/T/tag: _ (bool/T/tag) = 0 bool/T: bool (bool/T) = λa (a bool/T/tag) bool/F/tag: _ (bool/F/tag) = 1 bool/F: bool (bool/F) = λa (a bool/F/tag) ================================================ FILE: tests/snapshots/encode_pattern_match__match_adt_unscoped_lambda.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/match_adt_unscoped_lambda.bend --- Scott unchecked main: Any (main) = (Maybe_/Some 1 λ$x * λa a $x) Maybe_/None: Maybe_ (Maybe_/None) = λa λ* a Maybe_/Some: (Any -> Maybe_) (Maybe_/Some) = λa λ* λc (c a) NumScott unchecked main: Any (main) = (Maybe_/Some 1 λa switch a { 0: λ$x *; _: λ* λb b; } $x) Maybe_/None/tag: _ (Maybe_/None/tag) = 0 Maybe_/None: Maybe_ (Maybe_/None) = λa (a Maybe_/None/tag) Maybe_/Some/tag: _ (Maybe_/Some/tag) = 1 Maybe_/Some: (Any -> Maybe_) (Maybe_/Some) = λa λb (b Maybe_/Some/tag a) ================================================ FILE: tests/snapshots/encode_pattern_match__match_adt_unscoped_var.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/match_adt_unscoped_var.bend --- Scott unchecked Foo: Any (Foo) = λ$x (Maybe_/Some 1 $x λa a) unchecked Bar: Any (Bar) = (Maybe_/Some 1 $x λa a λ$x *) unchecked main: Any (main) = * Maybe_/None: Maybe_ (Maybe_/None) = λa λ* a Maybe_/Some: (Any -> Maybe_) (Maybe_/Some) = λa λ* λc (c a) NumScott unchecked Foo: Any (Foo) = λ$x (Maybe_/Some 1 λa switch a { 0: $x; _: λ* λb b; }) unchecked Bar: Any (Bar) = (Maybe_/Some 1 λa switch a { 0: $x; _: λ* λb b; } λ$x *) unchecked main: Any (main) = * Maybe_/None/tag: _ (Maybe_/None/tag) = 0 Maybe_/None: Maybe_ (Maybe_/None) = λa (a Maybe_/None/tag) Maybe_/Some/tag: _ (Maybe_/Some/tag) = 1 Maybe_/Some: (Any -> Maybe_) (Maybe_/Some) = λa λb (b Maybe_/Some/tag a) ================================================ FILE: tests/snapshots/encode_pattern_match__match_auto_linearization.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/match_auto_linearization.bend --- Scott unchecked switch_linearization: Any (switch_linearization) = λa let {a a_2 a_3 a_4} = a; λb let {b b_2 b_3 b_4 b_5} = b; let (c, d) = (a, b); let {d d_2} = d; let {c c_2} = c; switch a_2 { 0: let {e e_2} = 2; let {f g} = e; (b_2 e_2 f g (a_3, b_3) c d); _: λh let {i i_2} = 2; let {j k} = i; (h b_4 i_2 j k (a_4, b_5) c_2 d_2); } unchecked match_linearization: Any (match_linearization) = λa let {a a_2 a_3 a_4} = a; λb let {b b_2 b_3 b_4 b_5} = b; let (c, d) = (a, b); let {d d_2} = d; let {c c_2} = c; (a_2 λe let {f f_2} = 2; let {g h} = f; (e b_2 f_2 g h (a_3, b_3) c d) let {i i_2} = 2; let {j k} = i; (b_4 i_2 j k (a_4, b_5) c_2 d_2)) unchecked switch_shadowed_field: Any (switch_shadowed_field) = λa switch a { 0: λb b; _: λc λ* c; } unchecked match_shadowed_field: Any (match_shadowed_field) = λa (a λb λc (List/Cons b c) λd λe λ* λ* (List/Cons d e)) List/Cons: (T -> (List T) -> (List T)) (List/Cons) = λa λb λ* λd (d a b) NumScott unchecked switch_linearization: Any (switch_linearization) = λa let {a a_2 a_3 a_4} = a; λb let {b b_2 b_3 b_4 b_5} = b; let (c, d) = (a, b); let {d d_2} = d; let {c c_2} = c; switch a_2 { 0: let {e e_2} = 2; let {f g} = e; (b_2 e_2 f g (a_3, b_3) c d); _: λh let {i i_2} = 2; let {j k} = i; (h b_4 i_2 j k (a_4, b_5) c_2 d_2); } unchecked match_linearization: Any (match_linearization) = λa let {a a_2 a_3 a_4} = a; λb let {b b_2 b_3 b_4 b_5} = b; let (c, d) = (a, b); let {d d_2} = d; let {c c_2} = c; (a_2 λe switch e { 0: λf let {g g_2} = 2; let {h i} = g; (f b_2 g_2 h i (a_3, b_3) c d); _: λ* let {j j_2} = 2; let {k l} = j; (b_4 j_2 k l (a_4, b_5) c_2 d_2); }) unchecked switch_shadowed_field: Any (switch_shadowed_field) = λa switch a { 0: λb b; _: λc λ* c; } unchecked match_shadowed_field: Any (match_shadowed_field) = λa (a λb switch b { 0: λc λd (List/Cons c d); _: λ* λe λf λ* λ* (List/Cons e f); }) List/Cons/tag: _ (List/Cons/tag) = 1 List/Cons: (T -> (List T) -> (List T)) (List/Cons) = λa λb λc (c List/Cons/tag a b) ================================================ FILE: tests/snapshots/encode_pattern_match__match_bind.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/match_bind.bend --- Scott unchecked cheese: Any (cheese) = switch (+ 2 3) { 0: 653323; _: λa let {a a_2} = a; (+ (+ a 1) a_2); } unchecked main: Any (main) = cheese NumScott unchecked cheese: Any (cheese) = switch (+ 2 3) { 0: 653323; _: λa let {a a_2} = a; (+ (+ a 1) a_2); } unchecked main: Any (main) = cheese ================================================ FILE: tests/snapshots/encode_pattern_match__match_num_adt_tup_parser.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/match_num_adt_tup_parser.bend --- Scott unchecked Parse: Any (Parse) = λa λb (b λc (Result_/Err (String/Nil, c)) λd λe λf (switch (- d 10) { 0: λg λh (Result_/Ok (0, h, g)); _: λi λj λk (switch (- i 29) { 0: λl λm (Result_/Ok (40, m, l)); _: λn λo λp (switch n { 0: λq λr (Result_/Ok (41, r, q)); _: λs λt λu (Result_/Err ((String/Cons (+ s 42) u), t)); } o p); } j k); } f e) a) unchecked main: Any (main) = (Parse * (String/Cons 40 (String/Cons 43 String/Nil)) λc let (d, e, f) = c; (d, (Parse f e)) λg (Result_/Err g)) String/Nil: String (String/Nil) = λa λ* a String/Cons: (u24 -> String -> String) (String/Cons) = λa λb λ* λd (d a b) Result_/Ok: (Any -> Result_) (Result_/Ok) = λa λb λ* (b a) Result_/Err: (Any -> Result_) (Result_/Err) = λa λ* λc (c a) NumScott unchecked Parse: Any (Parse) = λa λb (b λc switch c { 0: λd (Result_/Err (String/Nil, d)); _: λ* λe λf λg (switch (- e 10) { 0: λh λi (Result_/Ok (0, i, h)); _: λj λk λl (switch (- j 29) { 0: λm λn (Result_/Ok (40, n, m)); _: λo λp λq (switch o { 0: λr λs (Result_/Ok (41, s, r)); _: λt λu λv (Result_/Err ((String/Cons (+ t 42) v), u)); } p q); } k l); } g f); } a) unchecked main: Any (main) = (Parse * (String/Cons 40 (String/Cons 43 String/Nil)) λc switch c { 0: λd let (e, f, g) = d; (e, (Parse g f)); _: λ* λh (Result_/Err h); }) String/Nil/tag: _ (String/Nil/tag) = 0 String/Nil: String (String/Nil) = λa (a String/Nil/tag) String/Cons/tag: _ (String/Cons/tag) = 1 String/Cons: (u24 -> String -> String) (String/Cons) = λa λb λc (c String/Cons/tag a b) Result_/Ok/tag: _ (Result_/Ok/tag) = 0 Result_/Ok: (Any -> Result_) (Result_/Ok) = λa λb (b Result_/Ok/tag a) Result_/Err/tag: _ (Result_/Err/tag) = 1 Result_/Err: (Any -> Result_) (Result_/Err) = λa λb (b Result_/Err/tag a) ================================================ FILE: tests/snapshots/encode_pattern_match__match_num_pred.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/match_num_pred.bend --- Scott unchecked pred: Any (pred) = λa switch a { 0: 0; _: λb b; } unchecked pred2: Any (pred2) = λa switch a { 0: 0; _: λb switch b { 0: 0; _: λc c; }; } unchecked pred3: Any (pred3) = λa switch a { 0: 0; _: λb switch b { 0: 0; _: λc switch c { 0: 0; _: λd d; }; }; } unchecked zero: Any (zero) = λa switch a { 0: 1; _: λb switch b { 0: 0; _: λ* 0; }; } unchecked main: Any (main) = * NumScott unchecked pred: Any (pred) = λa switch a { 0: 0; _: λb b; } unchecked pred2: Any (pred2) = λa switch a { 0: 0; _: λb switch b { 0: 0; _: λc c; }; } unchecked pred3: Any (pred3) = λa switch a { 0: 0; _: λb switch b { 0: 0; _: λc switch c { 0: 0; _: λd d; }; }; } unchecked zero: Any (zero) = λa switch a { 0: 1; _: λb switch b { 0: 0; _: λ* 0; }; } unchecked main: Any (main) = * ================================================ FILE: tests/snapshots/encode_pattern_match__match_syntax.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/match_syntax.bend --- Scott unchecked head: Any (head) = λa (a λb λ* b List_/Nil) List_/Cons: (Any -> Any -> List_) (List_/Cons) = λa λb λc λ* (c a b) List_/Nil: List_ (List_/Nil) = λ* λb b NumScott unchecked head: Any (head) = λa (a λb switch b { 0: λc λ* c; _: λ* List_/Nil; }) List_/Cons/tag: _ (List_/Cons/tag) = 0 List_/Cons: (Any -> Any -> List_) (List_/Cons) = λa λb λc (c List_/Cons/tag a b) List_/Nil/tag: _ (List_/Nil/tag) = 1 List_/Nil: List_ (List_/Nil) = λa (a List_/Nil/tag) ================================================ FILE: tests/snapshots/encode_pattern_match__merge_recursive.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/merge_recursive.bend --- Scott unchecked foo_1: Any (foo_1) = λa (a foo_2) unchecked foo_2: Any (foo_2) = λa λb (a, b) unchecked bar_1: Any (bar_1) = λa (a bar_2) unchecked bar_2: Any (bar_2) = λa λb (a, b) NumScott unchecked foo_1: Any (foo_1) = λa (a foo_2) unchecked foo_2: Any (foo_2) = λa λb (a, b) unchecked bar_1: Any (bar_1) = λa (a bar_2) unchecked bar_2: Any (bar_2) = λa λb (a, b) ================================================ FILE: tests/snapshots/encode_pattern_match__no_patterns.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/no_patterns.bend --- Scott unchecked Id: Any (Id) = λa a unchecked Id2: Any (Id2) = λa a unchecked Pair: Any (Pair) = λa λb (a, b) NumScott unchecked Id: Any (Id) = λa a unchecked Id2: Any (Id2) = λa a unchecked Pair: Any (Pair) = λa λb (a, b) ================================================ FILE: tests/snapshots/encode_pattern_match__non_matching_fst_arg.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/non_matching_fst_arg.bend --- Scott unchecked Foo: Any (Foo) = λa λb (b λc let {c c_2} = c; (Foo c c_2) λd d a) bool/true: bool (bool/true) = λa λ* a bool/false: bool (bool/false) = λ* λb b NumScott unchecked Foo: Any (Foo) = λa λb (b λc switch c { 0: λd let {d d_2} = d; (Foo d d_2); _: λ* λe e; } a) bool/true/tag: _ (bool/true/tag) = 0 bool/true: bool (bool/true) = λa (a bool/true/tag) bool/false/tag: _ (bool/false/tag) = 1 bool/false: bool (bool/false) = λa (a bool/false/tag) ================================================ FILE: tests/snapshots/encode_pattern_match__ntup_sum.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/ntup_sum.bend --- Scott unchecked ntupSum: Any (ntupSum) = λa let (b, c, d, e, f) = a; (+ b (+ c (+ d (+ e f)))) unchecked main: Any (main) = (ntupSum (1, 3, 3, 2, 1)) NumScott unchecked ntupSum: Any (ntupSum) = λa let (b, c, d, e, f) = a; (+ b (+ c (+ d (+ e f)))) unchecked main: Any (main) = (ntupSum (1, 3, 3, 2, 1)) ================================================ FILE: tests/snapshots/encode_pattern_match__pattern_match_encoding.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/pattern_match_encoding.bend --- Scott unchecked Foo: Any (Foo) = λa (a λ* 100 λ* 200 λ* 200 λ* λ* 200 λ* λ* 200) unchecked main: Any (main) = (Foo MyType/A 2) MyType/A: (Any -> MyType) (MyType/A) = λa λb λ* λ* λ* λ* (b a) MyType/B: (Any -> MyType) (MyType/B) = λa λ* λc λ* λ* λ* (c a) MyType/C: (Any -> MyType) (MyType/C) = λa λ* λ* λd λ* λ* (d a) MyType/D: (Any -> Any -> MyType) (MyType/D) = λa λb λ* λ* λ* λf λ* (f a b) MyType/E: (Any -> Any -> MyType) (MyType/E) = λa λb λ* λ* λ* λ* λg (g a b) NumScott unchecked Foo: Any (Foo) = λa (a λb switch b { 0: λ* 100; _: λd switch d { 0: λ* 200; _: λf switch f { 0: λ* 200; _: λh switch h { 0: λ* λ* 200; _: λ* λ* λ* 200; }; }; }; }) unchecked main: Any (main) = (Foo MyType/A 2) MyType/A/tag: _ (MyType/A/tag) = 0 MyType/A: (Any -> MyType) (MyType/A) = λa λb (b MyType/A/tag a) MyType/B/tag: _ (MyType/B/tag) = 1 MyType/B: (Any -> MyType) (MyType/B) = λa λb (b MyType/B/tag a) MyType/C/tag: _ (MyType/C/tag) = 2 MyType/C: (Any -> MyType) (MyType/C) = λa λb (b MyType/C/tag a) MyType/D/tag: _ (MyType/D/tag) = 3 MyType/D: (Any -> Any -> MyType) (MyType/D) = λa λb λc (c MyType/D/tag a b) MyType/E/tag: _ (MyType/E/tag) = 4 MyType/E: (Any -> Any -> MyType) (MyType/E) = λa λb λc (c MyType/E/tag a b) ================================================ FILE: tests/snapshots/encode_pattern_match__switch_in_switch_arg.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/switch_in_switch_arg.bend --- Scott unchecked main: Any (main) = λa switch switch a { 0: 0; _: λb b; } { 0: 0; _: λc (+ c 1); } NumScott unchecked main: Any (main) = λa switch switch a { 0: 0; _: λb b; } { 0: 0; _: λc (+ c 1); } ================================================ FILE: tests/snapshots/encode_pattern_match__var_only.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/var_only.bend --- Scott unchecked Foo: Any (Foo) = λa λ* λc (c a) unchecked main: Any (main) = λ* Foo Bool/False: Bool (Bool/False) = λa λ* a Bool/True: Bool (Bool/True) = λ* λb b NumScott unchecked Foo: Any (Foo) = λa λ* λc (c a) unchecked main: Any (main) = λ* Foo Bool/False/tag: _ (Bool/False/tag) = 0 Bool/False: Bool (Bool/False) = λa (a Bool/False/tag) Bool/True/tag: _ (Bool/True/tag) = 1 Bool/True: Bool (Bool/True) = λa (a Bool/True/tag) ================================================ FILE: tests/snapshots/encode_pattern_match__weekday.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/encode_pattern_match/weekday.bend --- Scott unchecked main: Any (main) = (λa a Weekday/Saturday) Weekday/Monday: Weekday (Weekday/Monday) = λa λ* λ* λ* λ* λ* λ* a Weekday/Tuesday: Weekday (Weekday/Tuesday) = λ* λb λ* λ* λ* λ* λ* b Weekday/Wednesday: Weekday (Weekday/Wednesday) = λ* λ* λc λ* λ* λ* λ* c Weekday/Thursday: Weekday (Weekday/Thursday) = λ* λ* λ* λd λ* λ* λ* d Weekday/Friday: Weekday (Weekday/Friday) = λ* λ* λ* λ* λe λ* λ* e Weekday/Saturday: Weekday (Weekday/Saturday) = λ* λ* λ* λ* λ* λf λ* f Weekday/Sunday: Weekday (Weekday/Sunday) = λ* λ* λ* λ* λ* λ* λg g NumScott unchecked main: Any (main) = (λa a Weekday/Saturday) Weekday/Monday/tag: _ (Weekday/Monday/tag) = 0 Weekday/Monday: Weekday (Weekday/Monday) = λa (a Weekday/Monday/tag) Weekday/Tuesday/tag: _ (Weekday/Tuesday/tag) = 1 Weekday/Tuesday: Weekday (Weekday/Tuesday) = λa (a Weekday/Tuesday/tag) Weekday/Wednesday/tag: _ (Weekday/Wednesday/tag) = 2 Weekday/Wednesday: Weekday (Weekday/Wednesday) = λa (a Weekday/Wednesday/tag) Weekday/Thursday/tag: _ (Weekday/Thursday/tag) = 3 Weekday/Thursday: Weekday (Weekday/Thursday) = λa (a Weekday/Thursday/tag) Weekday/Friday/tag: _ (Weekday/Friday/tag) = 4 Weekday/Friday: Weekday (Weekday/Friday) = λa (a Weekday/Friday/tag) Weekday/Saturday/tag: _ (Weekday/Saturday/tag) = 5 Weekday/Saturday: Weekday (Weekday/Saturday) = λa (a Weekday/Saturday/tag) Weekday/Sunday/tag: _ (Weekday/Sunday/tag) = 6 Weekday/Sunday: Weekday (Weekday/Sunday) = λa (a Weekday/Sunday/tag) ================================================ FILE: tests/snapshots/examples__bitonic_sort.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: examples/bitonic_sort.bend --- 16646144 ================================================ FILE: tests/snapshots/examples__bubble_sort.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: examples/bubble_sort.bend --- 4919 ================================================ FILE: tests/snapshots/examples__callcc.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: examples/callcc.bend --- 52 ================================================ FILE: tests/snapshots/examples__example_fun.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: examples/example_fun.bend --- 8 ================================================ FILE: tests/snapshots/examples__fib.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: examples/fib.bend --- 832040 ================================================ FILE: tests/snapshots/examples__fusing_add.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: examples/fusing_add.bend --- λa λb λ* (b λc λ* (c a)) ================================================ FILE: tests/snapshots/examples__fusing_not.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: examples/fusing_not.bend --- λa λb λc (a c b) ================================================ FILE: tests/snapshots/examples__gen_tree.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: examples/gen_tree.bend --- λa (a MyTree/Node/tag 1 λb (b MyTree/Node/tag 3 λc (c MyTree/Node/tag 7 λd (d MyTree/Node/tag 15 MyTree/Leaf MyTree/Leaf) λe (e MyTree/Node/tag 16 MyTree/Leaf MyTree/Leaf)) λf (f MyTree/Node/tag 8 λg (g MyTree/Node/tag 17 MyTree/Leaf MyTree/Leaf) λh (h MyTree/Node/tag 18 MyTree/Leaf MyTree/Leaf))) λi (i MyTree/Node/tag 4 λj (j MyTree/Node/tag 9 λk (k MyTree/Node/tag 19 MyTree/Leaf MyTree/Leaf) λl (l MyTree/Node/tag 20 MyTree/Leaf MyTree/Leaf)) λm (m MyTree/Node/tag 10 λn (n MyTree/Node/tag 21 MyTree/Leaf MyTree/Leaf) λo (o MyTree/Node/tag 22 MyTree/Leaf MyTree/Leaf)))) ================================================ FILE: tests/snapshots/examples__hello_world.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: examples/hello_world.bend --- λa (a IO/Done/tag IO/MAGIC 0) ================================================ FILE: tests/snapshots/examples__insertion_sort.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: examples/insertion_sort.bend --- [4780, 11739, 35809, 49583, 154358, 177867, 244878, 289211, 318852, 423850] ================================================ FILE: tests/snapshots/examples__list.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: examples/list.bend --- λa (a Result/Ok/tag 5) ================================================ FILE: tests/snapshots/examples__parallel_and.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: examples/parallel_and.bend --- Bool/True ================================================ FILE: tests/snapshots/examples__parallel_hello_world.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: examples/parallel_hello_world.bend --- 16744448 ================================================ FILE: tests/snapshots/examples__parallel_sum.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: examples/parallel_sum.bend --- 16744448 ================================================ FILE: tests/snapshots/examples__queue.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: examples/queue.bend --- [1, 2, 3] ================================================ FILE: tests/snapshots/examples__quick_sort.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: examples/quick_sort.bend --- 12741879 ================================================ FILE: tests/snapshots/examples__radix_sort.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: examples/radix_sort.bend --- 120 ================================================ FILE: tests/snapshots/import_system__import_ctr_syntax.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/import_system/import_ctr_syntax.bend --- λa (a lib/ctr_type/Ctr/Foo/tag 2 3) ================================================ FILE: tests/snapshots/import_system__import_main.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/import_system/import_main.bend --- Errors: Can not import the entry point of the program. ================================================ FILE: tests/snapshots/import_system__import_main2.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/import_system/import_main2.bend --- Errors: Can not import the entry point of the program. ================================================ FILE: tests/snapshots/import_system__import_main3.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/import_system/import_main3.bend --- Errors: Can not import the entry point of the program. ================================================ FILE: tests/snapshots/import_system__import_type.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/import_system/import_type.bend --- λa (a lib/MyOption/MyOption/Some/tag (1, 2)) ================================================ FILE: tests/snapshots/import_system__import_types.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/import_system/import_types.bend --- lib/types/Bool/False ================================================ FILE: tests/snapshots/import_system__imports.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/import_system/imports.bend --- 3 ================================================ FILE: tests/snapshots/import_system__imports_alias.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/import_system/imports_alias.bend --- 3 ================================================ FILE: tests/snapshots/import_system__imports_alias_shadow.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/import_system/imports_alias_shadow.bend --- Errors: The import 'lib/nums/two' shadows the imported name 'lib/nums/one' ================================================ FILE: tests/snapshots/import_system__imports_conflict.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/import_system/imports_conflict.bend --- Errors: The imported definition 'lib/a/b/C' conflicts with the definition 'lib/a/b/C'. The imported constructor 'lib/a/b/C' conflicts with the definition 'lib/a/b/C'. ================================================ FILE: tests/snapshots/import_system__imports_file_and_dir.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/import_system/imports_file_and_dir.bend --- (1, (3, 4)) ================================================ FILE: tests/snapshots/import_system__imports_file_and_dir_conflict.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/import_system/imports_file_and_dir_conflict.bend --- Errors: Both file 'lib/file_and_dir.bend' and folder 'lib/file_and_dir' contains the import 'w' ================================================ FILE: tests/snapshots/import_system__imports_shadow.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/import_system/imports_shadow.bend --- Errors: The import 'lib/myFun/myFun' shadows the imported name 'lib/folder/myFun/myFun' ================================================ FILE: tests/snapshots/import_system__imports_shadow2.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/import_system/imports_shadow2.bend --- Errors: The import 'lib/folder/myFun/myFun' shadows the imported name 'lib/myFun/myFun' ================================================ FILE: tests/snapshots/io__load.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/io/load.bend --- Strict mode: λa (a IO/Done/tag IO/MAGIC λb (b Result/Ok/tag "Contents\n")) ================================================ FILE: tests/snapshots/io__load_fail.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/io/load_fail.bend --- Strict mode: λa (a IO/Done/tag IO/MAGIC λb (b Result/Err/tag +2)) ================================================ FILE: tests/snapshots/io__read_line_eof.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/io/read_line_eof.bend --- Strict mode: λa (a IO/Done/tag IO/MAGIC "text") ================================================ FILE: tests/snapshots/io__store.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/io/store.bend --- Strict mode: λa (a IO/Done/tag IO/MAGIC λb (b Result/Ok/tag *)) ================================================ FILE: tests/snapshots/io__store_fail.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/io/store_fail.bend --- Strict mode: λa (a IO/Done/tag IO/MAGIC λb (b Result/Err/tag +2)) ================================================ FILE: tests/snapshots/io__utf8.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/io/utf8.bend --- Strict mode: ["hi", "(λf ((λx (f (x x))) (λx (f (x x)))))", "🌟", "Hello 🌎!", "𓆈 𓆉 𓆊 𓆋 𓅯", ""] ================================================ FILE: tests/snapshots/linear_readback__church_mul.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/linear_readback/church_mul.bend --- λa λb let {c $g} = (let {d $h} = a; d let {e f} = $h; (e (f {$g b}))); c ================================================ FILE: tests/snapshots/mutual_recursion__a_b_c.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/mutual_recursion/a_b_c.bend --- Errors: The following functions contain recursive cycles incompatible with HVM's strict evaluation: * A -> B -> C -> A The greedy eager evaluation of HVM may cause infinite loops. Refactor these functions to use lazy references instead of direct function calls. A reference is strict when it's being called ('(Foo x)') or when it's used non-linearly ('let x = Foo; (x x)'). It is lazy when it's an argument ('(x Foo)') or when it's used linearly ('let x = Foo; (x 0)'). Try one of these strategies: - Use pattern matching with 'match', 'fold', and 'bend' to automatically lift expressions to lazy references. - Replace direct calls with combinators. For example, change: 'Foo = λa λb (b (λc (Foo a c)) a)' to: 'Foo = λa λb (b (λc λa (Foo a c)) (λa a) a)' which is lifted to: 'Foo = λa λb (b Foo__C1 Foo__C2 a)' - Replace non-linear 'let' expressions with 'use' expressions. For example, change: 'Foo = λf let x = Foo; (f x x)' to: 'Foo = λf use x = Foo; (f x x)' which inlines to: 'Foo = λf (f Foo Foo)' - If disabled, re-enable the default 'float-combinators' and 'linearize-matches' compiler options. For more information, visit: https://github.com/HigherOrderCO/Bend/blob/main/docs/lazy-definitions.md. To disable this check, use the "-Arecursion-cycle" compiler option. ================================================ FILE: tests/snapshots/mutual_recursion__len.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/mutual_recursion/len.bend --- @Len = ((@Len__C1 a) a) @Len__C0 = (* (* (a c))) & $(b c) ~ [+0x0000001] & @Len ~ (a b) @Len__C1 = (?((0 @Len__C0) a) a) @List/Cons = (a (b ((@List/Cons/tag (a (b c))) c))) @List/Cons/tag = 1 @List/Nil = ((@List/Nil/tag a) a) @List/Nil/tag = 0 @main = g & @Len ~ (f g) & @List/Cons ~ (* (e f)) & @List/Cons ~ (* (d e)) & @List/Cons ~ (* (c d)) & @List/Cons ~ (* (b c)) & @List/Cons ~ (* (a b)) & @List/Cons ~ (* (@List/Nil a)) ================================================ FILE: tests/snapshots/mutual_recursion__merged.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/mutual_recursion/merged.bend --- Errors: The following functions contain recursive cycles incompatible with HVM's strict evaluation: * Rec -> X -> Rec * Rec -> Y -> Rec * Rec2 -> X -> Rec2 * Rec2 -> Y -> Rec2 The greedy eager evaluation of HVM may cause infinite loops. Refactor these functions to use lazy references instead of direct function calls. A reference is strict when it's being called ('(Foo x)') or when it's used non-linearly ('let x = Foo; (x x)'). It is lazy when it's an argument ('(x Foo)') or when it's used linearly ('let x = Foo; (x 0)'). Try one of these strategies: - Use pattern matching with 'match', 'fold', and 'bend' to automatically lift expressions to lazy references. - Replace direct calls with combinators. For example, change: 'Foo = λa λb (b (λc (Foo a c)) a)' to: 'Foo = λa λb (b (λc λa (Foo a c)) (λa a) a)' which is lifted to: 'Foo = λa λb (b Foo__C1 Foo__C2 a)' - Replace non-linear 'let' expressions with 'use' expressions. For example, change: 'Foo = λf let x = Foo; (f x x)' to: 'Foo = λf use x = Foo; (f x x)' which inlines to: 'Foo = λf (f Foo Foo)' - If disabled, re-enable the default 'float-combinators' and 'linearize-matches' compiler options. For more information, visit: https://github.com/HigherOrderCO/Bend/blob/main/docs/lazy-definitions.md. To disable this check, use the "-Arecursion-cycle" compiler option. ================================================ FILE: tests/snapshots/mutual_recursion__multiple.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/mutual_recursion/multiple.bend --- Errors: The following functions contain recursive cycles incompatible with HVM's strict evaluation: * A -> B -> C -> A * H -> I -> H * M -> M * N -> N The greedy eager evaluation of HVM may cause infinite loops. Refactor these functions to use lazy references instead of direct function calls. A reference is strict when it's being called ('(Foo x)') or when it's used non-linearly ('let x = Foo; (x x)'). It is lazy when it's an argument ('(x Foo)') or when it's used linearly ('let x = Foo; (x 0)'). Try one of these strategies: - Use pattern matching with 'match', 'fold', and 'bend' to automatically lift expressions to lazy references. - Replace direct calls with combinators. For example, change: 'Foo = λa λb (b (λc (Foo a c)) a)' to: 'Foo = λa λb (b (λc λa (Foo a c)) (λa a) a)' which is lifted to: 'Foo = λa λb (b Foo__C1 Foo__C2 a)' - Replace non-linear 'let' expressions with 'use' expressions. For example, change: 'Foo = λf let x = Foo; (f x x)' to: 'Foo = λf use x = Foo; (f x x)' which inlines to: 'Foo = λf (f Foo Foo)' - If disabled, re-enable the default 'float-combinators' and 'linearize-matches' compiler options. For more information, visit: https://github.com/HigherOrderCO/Bend/blob/main/docs/lazy-definitions.md. To disable this check, use the "-Arecursion-cycle" compiler option. ================================================ FILE: tests/snapshots/mutual_recursion__odd_even.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/mutual_recursion/odd_even.bend --- Errors: The following functions contain recursive cycles incompatible with HVM's strict evaluation: * isEven -> isOdd -> isEven The greedy eager evaluation of HVM may cause infinite loops. Refactor these functions to use lazy references instead of direct function calls. A reference is strict when it's being called ('(Foo x)') or when it's used non-linearly ('let x = Foo; (x x)'). It is lazy when it's an argument ('(x Foo)') or when it's used linearly ('let x = Foo; (x 0)'). Try one of these strategies: - Use pattern matching with 'match', 'fold', and 'bend' to automatically lift expressions to lazy references. - Replace direct calls with combinators. For example, change: 'Foo = λa λb (b (λc (Foo a c)) a)' to: 'Foo = λa λb (b (λc λa (Foo a c)) (λa a) a)' which is lifted to: 'Foo = λa λb (b Foo__C1 Foo__C2 a)' - Replace non-linear 'let' expressions with 'use' expressions. For example, change: 'Foo = λf let x = Foo; (f x x)' to: 'Foo = λf use x = Foo; (f x x)' which inlines to: 'Foo = λf (f Foo Foo)' - If disabled, re-enable the default 'float-combinators' and 'linearize-matches' compiler options. For more information, visit: https://github.com/HigherOrderCO/Bend/blob/main/docs/lazy-definitions.md. To disable this check, use the "-Arecursion-cycle" compiler option. ================================================ FILE: tests/snapshots/parse_file__bad_floating.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/bad_floating.bend --- Errors: In tests/golden_tests/parse_file/bad_floating.bend : - expected: newline - detected:  2 | return 0xA.0xA ================================================ FILE: tests/snapshots/parse_file__bend_missing_else.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/bend_missing_else.bend --- Errors: In tests/golden_tests/parse_file/bend_missing_else.bend : - expected: 'else' - detected:  14 | def main(): ================================================ FILE: tests/snapshots/parse_file__era.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/era.bend --- unchecked Main: Any (Main) = * ================================================ FILE: tests/snapshots/parse_file__fold_missing_case.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/fold_missing_case.bend --- Errors: In tests/golden_tests/parse_file/fold_missing_case.bend : - expected: 'case' - detected: end of input  4 |   ================================================ FILE: tests/snapshots/parse_file__fun_def.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/fun_def.bend --- unchecked main: Any (main) = let base = 0; def (aux (List/Nil)) = base(aux (List/Cons head tail)) = (+ head (aux tail))(aux (List/Cons 1 (List/Cons 2 (List/Cons 3 List/Nil)))) ================================================ FILE: tests/snapshots/parse_file__fun_def_name.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/fun_def_name.bend --- Errors: In tests/golden_tests/parse_file/fun_def_name.bend : Redefinition of builtin (constructor) 'List/Cons'. Location:  4 | aux2 (List/Cons head tail) = (+ head (aux tail)) ================================================ FILE: tests/snapshots/parse_file__if_missing_else.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/if_missing_else.bend --- Errors: In tests/golden_tests/parse_file/if_missing_else.bend : - expected: 'else' or 'elif' - detected: end of input  5 |   ================================================ FILE: tests/snapshots/parse_file__imp_map.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/imp_map.bend --- Maybe/unwrap: ((Maybe T) -> T) (Maybe/unwrap m) = match m = m { Maybe/Some: m.value; Maybe/None: unreachable; } Map/empty: (Map T) (Map/empty) = Map/Leaf Map/get: ((Map T) -> u24 -> (T, (Map T))) (Map/get map key) = match map = map { Map/Leaf: (unreachable, map); Map/Node: switch %pred = (== 0 key) { 0: switch %pred = (== (% key 2) 0) { 0: let (got, rest) = (Map/get map.right (/ key 2)); (got, (Map/Node map.value map.left rest)); _ %pred-1: let (got, rest) = (Map/get map.left (/ key 2)); (got, (Map/Node map.value rest map.right)); }; _ %pred-1: ((Maybe/unwrap map.value), map); }; } Map/set: ((Map T) -> u24 -> T -> (Map T)) (Map/set map key value) = match map = map { Map/Node: switch %pred = (== 0 key) { 0: switch %pred = (== (% key 2) 0) { 0: (Map/Node map.value map.left (Map/set map.right (/ key 2) value)); _ %pred-1: (Map/Node map.value (Map/set map.left (/ key 2) value) map.right); }; _ %pred-1: (Map/Node (Maybe/Some value) map.left map.right); }; Map/Leaf: switch %pred = (== 0 key) { 0: switch %pred = (== (% key 2) 0) { 0: (Map/Node Maybe/None Map/Leaf (Map/set Map/Leaf (/ key 2) value)); _ %pred-1: (Map/Node Maybe/None (Map/set Map/Leaf (/ key 2) value) Map/Leaf); }; _ %pred-1: (Map/Node (Maybe/Some value) Map/Leaf Map/Leaf); }; } unreachable: Any (unreachable) = * unchecked main: Any (main) = let x = (Map/set (Map/set Map/empty 2 1) 3 2); let (map/get%1, x) = (Map/get x 2); let y = (id map/get%1); let z = 4; let x = (Map/set x z 4); let (map/get%0, x) = (Map/get x z); (+ y map/get%0) Maybe/Some/tag: _ (Maybe/Some/tag) = 0 Maybe/Some: (T -> (Maybe T)) (Maybe/Some) = λvalue λ%x (%x Maybe/Some/tag value) Maybe/None/tag: _ (Maybe/None/tag) = 1 Maybe/None: (Maybe T) (Maybe/None) = λ%x (%x Maybe/None/tag) Map/Node/tag: _ (Map/Node/tag) = 0 Map/Node: ((Maybe T) -> (Map T) -> (Map T) -> (Map T)) (Map/Node) = λvalue λleft λright λ%x (%x Map/Node/tag value left right) Map/Leaf/tag: _ (Map/Leaf/tag) = 1 Map/Leaf: (Map T) (Map/Leaf) = λ%x (%x Map/Leaf/tag) ================================================ FILE: tests/snapshots/parse_file__imp_program.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/imp_program.bend --- Maybe/unwrap: ((Maybe T) -> T) (Maybe/unwrap m) = match m = m { Maybe/Some: m.value; Maybe/None: unreachable; } Map/empty: (Map T) (Map/empty) = Map/Leaf Map/get: ((Map T) -> u24 -> (T, (Map T))) (Map/get map key) = match map = map { Map/Leaf: (unreachable, map); Map/Node: switch %pred = (== 0 key) { 0: switch %pred = (== (% key 2) 0) { 0: let (got, rest) = (Map/get map.right (/ key 2)); (got, (Map/Node map.value map.left rest)); _ %pred-1: let (got, rest) = (Map/get map.left (/ key 2)); (got, (Map/Node map.value rest map.right)); }; _ %pred-1: ((Maybe/unwrap map.value), map); }; } Map/set: ((Map T) -> u24 -> T -> (Map T)) (Map/set map key value) = match map = map { Map/Node: switch %pred = (== 0 key) { 0: switch %pred = (== (% key 2) 0) { 0: (Map/Node map.value map.left (Map/set map.right (/ key 2) value)); _ %pred-1: (Map/Node map.value (Map/set map.left (/ key 2) value) map.right); }; _ %pred-1: (Map/Node (Maybe/Some value) map.left map.right); }; Map/Leaf: switch %pred = (== 0 key) { 0: switch %pred = (== (% key 2) 0) { 0: (Map/Node Maybe/None Map/Leaf (Map/set Map/Leaf (/ key 2) value)); _ %pred-1: (Map/Node Maybe/None (Map/set Map/Leaf (/ key 2) value) Map/Leaf); }; _ %pred-1: (Map/Node (Maybe/Some value) Map/Leaf Map/Leaf); }; } unreachable: Any (unreachable) = * unchecked symbols: Any (symbols) = let x = (Map/set (Map/set Map/empty 49 5) 2 3); let x = (Map/set x 49 2); let x = (Map/set x 2 3); let (map/get%0, x) = (Map/get x 49); (+ map/get%0 8293490) unchecked mk_point: Any (mk_point) = (Point/Point 1 2) unchecked identity: (Any -> Any) (identity x) = x unchecked inc: (Any -> Any) (inc n) = let n = (+ n 1); n unchecked inc_list: (Any -> Any) (inc_list list) = fold %iter = list { List/Nil: List/Nil; List/Cons: let x = %iter.head; (List/Cons (+ x 1) %iter.tail); } unchecked lam: Any (lam) = λx λy x unchecked do_match: (Any -> Any) (do_match b) = match b = b { Bool/True: 1; Bool/False: 0; } unchecked true: Any (true) = Bool/True unchecked fib: (Any -> Any) (fib n) = switch %pred = (< n 2) { 0: (+ (fib (- n 1)) (fib (- n 2))); _ %pred-1: n; } unchecked swt: (Any -> Any) (swt n) = switch n = n { 0: 42; _ n-1: 1; } unchecked fld: (Any -> Any) (fld list) = fold list = list { List/Cons: 1; List/Nil: 2; } unchecked bnd: Any (bnd) = bend x = 0, { when (< x 10): (List/Cons x (fork (+ x 1))); else: List/Nil } unchecked era: Any (era) = let * = (+ 2 3); let the_expr_killer = *; (the_expr_killer 9) unchecked sup: Any (sup) = let x = {(List/Cons 1 (List/Cons 2 List/Nil)) (List/Cons 3 (List/Cons 4 (List/Cons 5 (List/Cons 6 List/Nil))))}; x unchecked main: Any (main) = with IO { ask x = IO.read; x } List/Nil/tag: _ (List/Nil/tag) = 0 List/Nil: (List T) (List/Nil) = λ%x (%x List/Nil/tag) List/Cons/tag: _ (List/Cons/tag) = 1 List/Cons: (T -> (List T) -> (List T)) (List/Cons) = λhead λtail λ%x (%x List/Cons/tag head tail) Maybe/Some/tag: _ (Maybe/Some/tag) = 0 Maybe/Some: (T -> (Maybe T)) (Maybe/Some) = λvalue λ%x (%x Maybe/Some/tag value) Maybe/None/tag: _ (Maybe/None/tag) = 1 Maybe/None: (Maybe T) (Maybe/None) = λ%x (%x Maybe/None/tag) Map/Node/tag: _ (Map/Node/tag) = 0 Map/Node: ((Maybe T) -> (Map T) -> (Map T) -> (Map T)) (Map/Node) = λvalue λleft λright λ%x (%x Map/Node/tag value left right) Map/Leaf/tag: _ (Map/Leaf/tag) = 1 Map/Leaf: (Map T) (Map/Leaf) = λ%x (%x Map/Leaf/tag) Point/Point/tag: _ (Point/Point/tag) = 0 Point/Point: (Any -> Any -> Point) (Point/Point) = λx λy λ%x (%x Point/Point/tag x y) Bool/True/tag: _ (Bool/True/tag) = 0 Bool/True: Bool (Bool/True) = λ%x (%x Bool/True/tag) Bool/False/tag: _ (Bool/False/tag) = 1 Bool/False: Bool (Bool/False) = λ%x (%x Bool/False/tag) ================================================ FILE: tests/snapshots/parse_file__match_missing_case.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/match_missing_case.bend --- Errors: In tests/golden_tests/parse_file/match_missing_case.bend : - expected: 'case' - detected: end of input  4 |   ================================================ FILE: tests/snapshots/parse_file__multi_line_comment.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/multi_line_comment.bend --- unchecked X: Any (X x x x) = x unchecked String/is_empty: Any (String/is_empty s) = match s = s { String/Nil: 1; String/Cons: 0; } unchecked main: Any (main) = 0 unchecked String/not_empty: (Any -> Any) (String/not_empty s) = match s = s { String/Nil: 0; String/Cons: 1; } Foo/Foo/tag: _ (Foo/Foo/tag) = 0 Foo/Foo: (Any -> Foo) (Foo/Foo) = λfoo λ%x (%x Foo/Foo/tag foo) Bar/tag: _ (Bar/tag) = 0 Bar: (Any -> Bar) (Bar) = λbar λ%x (%x Bar/tag bar) V/V/tag: _ (V/V/tag) = 0 V/V: V (V/V) = λ%x (%x V/V/tag) ================================================ FILE: tests/snapshots/parse_file__redefinition_builtin.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/redefinition_builtin.bend --- Errors: In tests/golden_tests/parse_file/redefinition_builtin.bend : Redefinition of builtin (function) 'Map/get'. Location: end of input  1 | def Map/get(m):  2 |  return m  ================================================ FILE: tests/snapshots/parse_file__redefinition_ctr_with_fun.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/redefinition_ctr_with_fun.bend --- Errors: In tests/golden_tests/parse_file/redefinition_ctr_with_fun.bend : Redefinition of builtin (constructor) 'String/Cons'. Location: end of input  1 | def String/Cons(x):  2 |  return x  ================================================ FILE: tests/snapshots/parse_file__redefinition_fun_imp.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/redefinition_fun_imp.bend --- Errors: In tests/golden_tests/parse_file/redefinition_fun_imp.bend : Redefinition of function 'A'. Location: end of input  3 | def A:  4 |  return 0 ================================================ FILE: tests/snapshots/parse_file__redefinition_imp_fun.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/redefinition_imp_fun.bend --- Errors: In tests/golden_tests/parse_file/redefinition_imp_fun.bend : Redefinition of function 'A'. Location: end of input  5 | (A) = 1 ================================================ FILE: tests/snapshots/parse_file__redefinition_type_with_object.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/redefinition_type_with_object.bend --- Errors: In tests/golden_tests/parse_file/redefinition_type_with_object.bend : Redefinition of builtin (type) 'IO'. Location: end of input  1 | object IO { run }  ================================================ FILE: tests/snapshots/parse_file__redefinition_with_def_between.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/redefinition_with_def_between.bend --- Errors: In tests/golden_tests/parse_file/redefinition_with_def_between.bend : Redefinition of function 'A'. Location: end of input  4 | (A) = @x x ================================================ FILE: tests/snapshots/parse_file__redefinition_with_object_between.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/redefinition_with_object_between.bend --- Errors: In tests/golden_tests/parse_file/redefinition_with_object_between.bend : Redefinition of function 'A'. Location: end of input  3 | A = 1 ================================================ FILE: tests/snapshots/parse_file__redefinition_with_type_between.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/redefinition_with_type_between.bend --- Errors: In tests/golden_tests/parse_file/redefinition_with_type_between.bend : Redefinition of function 'A'. Location:  3 | A = 1 ================================================ FILE: tests/snapshots/parse_file__repeated_adt_name.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/repeated_adt_name.bend --- Errors: In tests/golden_tests/parse_file/repeated_adt_name.bend : Redefinition of type 'Foo'. Location:  2 | type Foo = B  3 |   4 | main = * ================================================ FILE: tests/snapshots/parse_file__repeated_datatype_name.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/repeated_datatype_name.bend --- Errors: In tests/golden_tests/parse_file/repeated_datatype_name.bend : Found a repeated field 'Expr' in constructor Expr/Plus. Location:  3 | | (Plus Expr Expr) ================================================ FILE: tests/snapshots/parse_file__scape_chars.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/scape_chars.bend --- unchecked main: Any (main) = (String/Cons 92 (String/Cons 32 (String/Cons 10 (String/Cons 32 (String/Cons 9 (String/Cons 32 (String/Cons 34 String/Nil))))))) String/Nil/tag: _ (String/Nil/tag) = 0 String/Nil: String (String/Nil) = λ%x (%x String/Nil/tag) String/Cons/tag: _ (String/Cons/tag) = 1 String/Cons: (u24 -> String -> String) (String/Cons) = λhead λtail λ%x (%x String/Cons/tag head tail) ================================================ FILE: tests/snapshots/parse_file__strange_pattern.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/strange_pattern.bend --- Errors: In tests/golden_tests/parse_file/strange_pattern.bend : - expected: pattern or '=' - detected:  1 | main & = (a b c) ================================================ FILE: tests/snapshots/parse_file__tab.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/tab.bend --- Errors: In tests/golden_tests/parse_file/tab.bend : Tabs are not accepted for indentation. Location:  2 |  x = 2 ================================================ FILE: tests/snapshots/parse_file__tup_with_signed.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/tup_with_signed.bend --- unchecked main: Any (main) = let a = (+1, +1); let b = 1.132; let c = (-6.234, -1); let d = -1; let e = (+6 * λx x); let f = (* λx x); (+ a (+ b (+ c (+ d (- e f))))) ================================================ FILE: tests/snapshots/parse_file__tuple_assign.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/tuple_assign.bend --- unchecked main: Any (main) = let (first, second) = (1, (2, 3)); second ================================================ FILE: tests/snapshots/parse_file__tuple_commas.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/tuple_commas.bend --- unchecked main: Any (main) = let tup = ((fst 1 λx x), 2); (tup, 3, (4, 5)) unchecked fst: (Any -> Any -> Any) (fst x y) = x ================================================ FILE: tests/snapshots/parse_file__tuple_need_parens.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/parse_file/tuple_need_parens.bend --- unchecked main: Any (main) = switch %pred = (1, 2) { 0: (String/Cons 104 (String/Cons 109 (String/Cons 109 (String/Cons 109 String/Nil)))); _ %pred-1: (String/Cons 110 (String/Cons 111 (String/Cons 116 String/Nil))); } String/Nil/tag: _ (String/Nil/tag) = 0 String/Nil: String (String/Nil) = λ%x (%x String/Nil/tag) String/Cons/tag: _ (String/Cons/tag) = 1 String/Cons: (u24 -> String -> String) (String/Cons) = λhead λtail λ%x (%x String/Cons/tag head tail) ================================================ FILE: tests/snapshots/prelude__applies_function_to_map.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/prelude/applies_function_to_map.bend --- Strict mode: 257 ================================================ FILE: tests/snapshots/prelude__get_values_from_map.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/prelude/get_values_from_map.bend --- Strict mode: 3 ================================================ FILE: tests/snapshots/prelude__lists_to_map.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/prelude/lists_to_map.bend --- Strict mode: Map/Leaf ================================================ FILE: tests/snapshots/prelude__map_checked_test.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/prelude/map_checked_test.bend --- Strict mode: (λa (a Maybe/Some/tag 2), λb (b Map/Node/tag λc (c Maybe/Some/tag 1) Map/Leaf λd (d Map/Node/tag Maybe/None Map/Leaf λe (e Map/Node/tag λf (f Maybe/Some/tag 2) Map/Leaf Map/Leaf)))) ================================================ FILE: tests/snapshots/prelude__map_contains_test.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/prelude/map_contains_test.bend --- Strict mode: (0, λa (a Map/Node/tag λb (b Maybe/Some/tag 23) Map/Leaf Map/Leaf)) ================================================ FILE: tests/snapshots/prelude__set_node_when_empty.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/prelude/set_node_when_empty.bend --- Strict mode: λa (a Map/Node/tag λb (b Maybe/Some/tag 42) Map/Leaf λc (c Map/Node/tag λd (d Maybe/Some/tag 23) Map/Leaf λe (e Map/Node/tag λf (f Maybe/Some/tag 4) Map/Leaf Map/Leaf))) ================================================ FILE: tests/snapshots/readback_hvm__addition.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/readback_hvm/addition.bend --- (+ 2 1) ================================================ FILE: tests/snapshots/readback_hvm__bad_net.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/readback_hvm/bad_net.bend --- Warnings: During readback: Unable to interpret the HVM result as a valid Bend term. (Reached Root) ================================================ FILE: tests/snapshots/readback_hvm__bad_net1.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/readback_hvm/bad_net1.bend --- λa λb a ================================================ FILE: tests/snapshots/readback_hvm__bad_net3.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/readback_hvm/bad_net3.bend --- λa λb a ================================================ FILE: tests/snapshots/readback_hvm__complicated_dup.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/readback_hvm/complicated_dup.bend --- λa (λ$b (a ($b $c)) λ$c (a ($b $c))) ================================================ FILE: tests/snapshots/readback_hvm__fst_snd.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/readback_hvm/fst_snd.bend --- (λa a (λb b {{1 3} 2})) ================================================ FILE: tests/snapshots/readback_hvm__id.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/readback_hvm/id.bend --- λa a ================================================ FILE: tests/snapshots/readback_hvm__invalid_op2_op2.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/readback_hvm/invalid_op2_op2.bend --- Warnings: During readback: Encountered an invalid numeric operation. (3 occurrences) λa ================================================ FILE: tests/snapshots/readback_hvm__match.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/readback_hvm/match.bend --- switch a = 1 { 0: λb b; _: a-1; } ================================================ FILE: tests/snapshots/readback_hvm__nested_let.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/readback_hvm/nested_let.bend --- 3 ================================================ FILE: tests/snapshots/readback_hvm__nested_tup.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/readback_hvm/nested_tup.bend --- {{1 2} {4 {3 5}}} ================================================ FILE: tests/snapshots/readback_hvm__number.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/readback_hvm/number.bend --- 10 ================================================ FILE: tests/snapshots/readback_hvm__simple_tup.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/readback_hvm/simple_tup.bend --- {0 42} ================================================ FILE: tests/snapshots/readback_hvm__tup_add.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/readback_hvm/tup_add.bend --- (+ 1 2) ================================================ FILE: tests/snapshots/run_file__360_no_scope.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/360_no_scope.bend --- Errors: In tests/golden_tests/run_file/360_no_scope.bend : - expected: '=' - detected: end of input  6 |   ================================================ FILE: tests/snapshots/run_file__addition.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/addition.bend --- NumScott: 10 Scott: 10 ================================================ FILE: tests/snapshots/run_file__adt_match.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/adt_match.bend --- NumScott: λa (a Opt/Some/tag 2) Scott: λa λ* (a 2) ================================================ FILE: tests/snapshots/run_file__adt_match_wrong_tag.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/adt_match_wrong_tag.bend --- Errors: In tests/golden_tests/run_file/adt_match_wrong_tag.bend : - expected: term - detected: end of input  4 |   ================================================ FILE: tests/snapshots/run_file__adt_option_and.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/adt_option_and.bend --- NumScott: λa (a λb switch b = b { 0: λc λd (d λe switch e = e { 0: λf λg λh (h Option/Some/tag λi f); _: λ* Option/None; } c); _: λ* Option/None; }) Scott: λa (a λb λc (c λd λe λf λ* (f λg d) λ* Option/None b) λ* Option/None) ================================================ FILE: tests/snapshots/run_file__adt_wrong_tag.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/adt_wrong_tag.bend --- Errors: In tests/golden_tests/run_file/adt_wrong_tag.bend : - expected: term - detected: end of input  4 |   ================================================ FILE: tests/snapshots/run_file__and.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/and.bend --- NumScott: bool/false Scott: bool/false ================================================ FILE: tests/snapshots/run_file__basic_num_ops.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/basic_num_ops.bend --- NumScott: [30, 10, 200, 2, 0, 30, 0, 30, 0, 1, 0, 1, 40, 2, 65535, +30, +10, +200, +2, +0, +30, +0, +30, 0, 1, 0, 1, 65535, -30, -10, +200, +2, +0, +26, -28, -2, 0, 1, 1, 0, 65535, +10, +30, -200, -2, +0, -30, +20, -10, 0, 1, 0, 1, 65535, -10, -30, -200, -2, +0, -26, +8, -18, 0, 1, 1, 0, 65535, 30.000, 10.000, 200.000, 2.000, 0.000, 10240007340032.000, 1.107, 0.769, 0, 1, 0, 1, 65535, -30.000, -10.000, 200.000, 2.000, -0.000, 0.000, -2.034, NaN, 0, 1, 1, 0, 65535, 10.000, 30.000, -200.000, -2.000, 0.000, 0.000, 2.034, NaN, 0, 1, 0, 1, 65535, -10.000, -30.000, -200.000, -2.000, -0.000, 10240007340032.000, -1.107, NaN, 0, 1, 1, 0, 65535, 0.631, 0.643] Scott: [30, 10, 200, 2, 0, 30, 0, 30, 0, 1, 0, 1, 40, 2, 65535, +30, +10, +200, +2, +0, +30, +0, +30, 0, 1, 0, 1, 65535, -30, -10, +200, +2, +0, +26, -28, -2, 0, 1, 1, 0, 65535, +10, +30, -200, -2, +0, -30, +20, -10, 0, 1, 0, 1, 65535, -10, -30, -200, -2, +0, -26, +8, -18, 0, 1, 1, 0, 65535, 30.000, 10.000, 200.000, 2.000, 0.000, 10240007340032.000, 1.107, 0.769, 0, 1, 0, 1, 65535, -30.000, -10.000, 200.000, 2.000, -0.000, 0.000, -2.034, NaN, 0, 1, 1, 0, 65535, 10.000, 30.000, -200.000, -2.000, 0.000, 0.000, 2.034, NaN, 0, 1, 0, 1, 65535, -10.000, -30.000, -200.000, -2.000, -0.000, 10240007340032.000, -1.107, NaN, 0, 1, 1, 0, 65535, 0.631, 0.643] ================================================ FILE: tests/snapshots/run_file__bend_fold.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/bend_fold.bend --- NumScott: 24 Scott: 24 ================================================ FILE: tests/snapshots/run_file__bitonic_sort.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/bitonic_sort.bend --- NumScott: 120 Scott: 120 ================================================ FILE: tests/snapshots/run_file__bitonic_sort_lam.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/bitonic_sort_lam.bend --- NumScott: 32640 Scott: 32640 ================================================ FILE: tests/snapshots/run_file__box.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/box.bend --- NumScott: λa (a _Box/Box/tag λb (b _Box/Box/tag 10)) Scott: λa (a λb (b 10)) ================================================ FILE: tests/snapshots/run_file__branch_statements_assignment.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/branch_statements_assignment.bend --- NumScott: 6 Scott: 6 ================================================ FILE: tests/snapshots/run_file__callcc.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/callcc.bend --- NumScott: 52 Scott: 52 ================================================ FILE: tests/snapshots/run_file__chars.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/chars.bend --- NumScott: "ሴ!7" Scott: "ሴ!7" ================================================ FILE: tests/snapshots/run_file__chars_forall.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/chars_forall.bend --- NumScott: 8704 Scott: 8704 ================================================ FILE: tests/snapshots/run_file__chars_lambda.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/chars_lambda.bend --- NumScott: 955 Scott: 955 ================================================ FILE: tests/snapshots/run_file__checked_scott_encoding.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/checked_scott_encoding.bend --- Errors: In λa λb (a λe λf λg λh (g e (scott_concat f b)) b): Can't unify '(e -> c -> j)' and '(((d -> e -> (d -> j -> k) -> g -> k) -> c -> m) -> c -> m)'. Variable 'e' occurs in '((d -> e -> (d -> j -> k) -> g -> k) -> c -> m)' ================================================ FILE: tests/snapshots/run_file__comprehension.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/comprehension.bend --- NumScott: [5, 10, 7, 6] Scott: [5, 10, 7, 6] ================================================ FILE: tests/snapshots/run_file__def_bool_num.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/def_bool_num.bend --- Errors: In tests/golden_tests/run_file/def_bool_num.bend : In definition 'go': Non-exhaustive pattern matching rule. Default case of number type not covered. ================================================ FILE: tests/snapshots/run_file__def_num_bool.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/def_num_bool.bend --- Errors: In tests/golden_tests/run_file/def_num_bool.bend : In definition 'go': Non-exhaustive pattern matching rule. Default case of number type not covered. ================================================ FILE: tests/snapshots/run_file__def_tups.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/def_tups.bend --- NumScott: 15 Scott: 15 ================================================ FILE: tests/snapshots/run_file__do_block_mixed.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/do_block_mixed.bend --- NumScott: λa (a Result/Ok/tag 1) Scott: λa λ* (a 1) ================================================ FILE: tests/snapshots/run_file__dup_global_lam.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/dup_global_lam.bend --- NumScott: λa a Scott: λa a ================================================ FILE: tests/snapshots/run_file__empty.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/empty.bend --- Errors: File has no 'main' definition. ================================================ FILE: tests/snapshots/run_file__encode_decode_utf8.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/encode_decode_utf8.bend --- NumScott: ([72, 101, 108, 108, 111, 44, 32, 228, 184, 150, 231, 149, 140, 33], "Hello, 世界!") Scott: ([72, 101, 108, 108, 111, 44, 32, 228, 184, 150, 231, 149, 140, 33], "Hello, 世界!") ================================================ FILE: tests/snapshots/run_file__erased_side_effect.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/erased_side_effect.bend --- NumScott: 123 Scott: 123 ================================================ FILE: tests/snapshots/run_file__escape_sequences.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/escape_sequences.bend --- NumScott: "\n\r\t\0\"'\u{afe}\\\n\r\t\0\"'\u{afe}\\" Scott: "\n\r\t\0\"'\u{afe}\\\n\r\t\0\"'\u{afe}\\" ================================================ FILE: tests/snapshots/run_file__eta.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/eta.bend --- NumScott: Id Scott: Id ================================================ FILE: tests/snapshots/run_file__example.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/example.bend --- NumScott: 8 Scott: 8 ================================================ FILE: tests/snapshots/run_file__exp.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/exp.bend --- NumScott: Warnings: During readback: Unable to interpret the HVM result as a valid Bend term. (Reached Root) λa λb ( λ$c $c $c) Scott: Warnings: During readback: Unable to interpret the HVM result as a valid Bend term. (Reached Root) λa λb ( λ$c $c $c) ================================================ FILE: tests/snapshots/run_file__expand_main_combinator.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/expand_main_combinator.bend --- NumScott: λa (a 1 2) Scott: λa (a 1 2) ================================================ FILE: tests/snapshots/run_file__expand_main_list.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/expand_main_list.bend --- NumScott: [1, 2, 3] Scott: [1, 2, 3] ================================================ FILE: tests/snapshots/run_file__extracted_match_pred.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/extracted_match_pred.bend --- NumScott: valZ Scott: valZ ================================================ FILE: tests/snapshots/run_file__filter_bool_id.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/filter_bool_id.bend --- NumScott: [Bool/T] Scott: [Bool/T] ================================================ FILE: tests/snapshots/run_file__floating_numbers.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/floating_numbers.bend --- NumScott: [18.072, 0.125, 5.625, 2863333376.000, 10.625] Scott: [18.072, 0.125, 5.625, 2863333376.000, 10.625] ================================================ FILE: tests/snapshots/run_file__fold_with_state.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/fold_with_state.bend --- NumScott: [1, 2, 3] Scott: [1, 2, 3] ================================================ FILE: tests/snapshots/run_file__guide_bend_7tree.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_bend_7tree.bend --- NumScott: λa (a Tree/Node/tag λb (b Tree/Node/tag λc (c Tree/Node/tag λd (d Tree/Leaf/tag 7) λe (e Tree/Leaf/tag 7)) λf (f Tree/Node/tag λg (g Tree/Leaf/tag 7) λh (h Tree/Leaf/tag 7))) λi (i Tree/Node/tag λj (j Tree/Node/tag λk (k Tree/Leaf/tag 7) λl (l Tree/Leaf/tag 7)) λm (m Tree/Node/tag λn (n Tree/Leaf/tag 7) λo (o Tree/Leaf/tag 7)))) Scott: λa λ* (a λb λ* (b λc λ* (c λ* λd (d 7) λ* λe (e 7)) λf λ* (f λ* λg (g 7) λ* λh (h 7))) λi λ* (i λj λ* (j λ* λk (k 7) λ* λl (l 7)) λm λ* (m λ* λn (n 7) λ* λo (o 7)))) ================================================ FILE: tests/snapshots/run_file__guide_bend_sequential.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_bend_sequential.bend --- NumScott: 45 Scott: 45 ================================================ FILE: tests/snapshots/run_file__guide_bend_sum_tree.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_bend_sum_tree.bend --- NumScott: 16760832 Scott: 16760832 ================================================ FILE: tests/snapshots/run_file__guide_bitonic_sort.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_bitonic_sort.bend --- NumScott: 523776 Scott: 523776 ================================================ FILE: tests/snapshots/run_file__guide_circle_area.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_circle_area.bend --- NumScott: 314.000 Scott: 314.000 ================================================ FILE: tests/snapshots/run_file__guide_distance_4args.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_distance_4args.bend --- NumScott: 14.142 Scott: 14.142 ================================================ FILE: tests/snapshots/run_file__guide_distance_obj.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_distance_obj.bend --- NumScott: 14.142 Scott: 14.142 ================================================ FILE: tests/snapshots/run_file__guide_distance_tup.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_distance_tup.bend --- NumScott: 14.142 Scott: 14.142 ================================================ FILE: tests/snapshots/run_file__guide_enumerate.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_enumerate.bend --- NumScott: λa (a Tree/Node/tag λb (b Tree/Node/tag λc (c Tree/Leaf/tag (0, 1)) λd (d Tree/Leaf/tag (1, 2))) λe (e Tree/Node/tag λf (f Tree/Leaf/tag (2, 3)) λg (g Tree/Leaf/tag (3, 4)))) Scott: λa λ* (a λb λ* (b λ* λc (c (0, 1)) λ* λd (d (1, 2))) λe λ* (e λ* λf (f (2, 3)) λ* λg (g (3, 4)))) ================================================ FILE: tests/snapshots/run_file__guide_if_age.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_if_age.bend --- NumScott: "you're an adult" Scott: "you're an adult" ================================================ FILE: tests/snapshots/run_file__guide_is_even_num.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_is_even_num.bend --- NumScott: 0 Scott: 0 ================================================ FILE: tests/snapshots/run_file__guide_is_even_str.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_is_even_str.bend --- NumScott: "odd" Scott: "odd" ================================================ FILE: tests/snapshots/run_file__guide_list_ctrs.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_list_ctrs.bend --- NumScott: [1, 2, 3] Scott: [1, 2, 3] ================================================ FILE: tests/snapshots/run_file__guide_list_match.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_list_match.bend --- NumScott: 1 Scott: 1 ================================================ FILE: tests/snapshots/run_file__guide_list_sugar.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_list_sugar.bend --- NumScott: [1, 2, 3] Scott: [1, 2, 3] ================================================ FILE: tests/snapshots/run_file__guide_mul2_inline.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_mul2_inline.bend --- NumScott: 14 Scott: 14 ================================================ FILE: tests/snapshots/run_file__guide_mul2_rec.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_mul2_rec.bend --- NumScott: 14 Scott: 14 ================================================ FILE: tests/snapshots/run_file__guide_shader_dummy.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_shader_dummy.bend --- NumScott: (((((1, 1), (1, 1)), ((1, 1), (1, 1))), (((1, 1), (1, 1)), ((1, 1), (1, 1)))), ((((1, 1), (1, 1)), ((1, 1), (1, 1))), (((1, 1), (1, 1)), ((1, 1), (1, 1))))) Scott: (((((1, 1), (1, 1)), ((1, 1), (1, 1))), (((1, 1), (1, 1)), ((1, 1), (1, 1)))), ((((1, 1), (1, 1)), ((1, 1), (1, 1))), (((1, 1), (1, 1)), ((1, 1), (1, 1))))) ================================================ FILE: tests/snapshots/run_file__guide_sum.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/guide_sum.bend --- NumScott: 10 Scott: 10 ================================================ FILE: tests/snapshots/run_file__hvm_def_cast.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/hvm_def_cast.bend --- NumScott: 42.000 Scott: 42.000 ================================================ FILE: tests/snapshots/run_file__hvm_def_two_defs.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/hvm_def_two_defs.bend --- NumScott: -0.349 Scott: -0.349 ================================================ FILE: tests/snapshots/run_file__id_underscore.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/id_underscore.bend --- NumScott: {2 3} Scott: {2 3} ================================================ FILE: tests/snapshots/run_file__imp_empty_literals.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/imp_empty_literals.bend --- NumScott: λa (a List/Nil/tag) Scott: λa λ* a ================================================ FILE: tests/snapshots/run_file__imp_use_statement.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/imp_use_statement.bend --- NumScott: λa {{1 a} {1 a}} Scott: λa {{1 a} {1 a}} ================================================ FILE: tests/snapshots/run_file__kind_compiled_tree_sum.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/kind_compiled_tree_sum.bend --- NumScott: 16678913 Scott: 16678913 ================================================ FILE: tests/snapshots/run_file__lam_op2.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/lam_op2.bend --- NumScott: λa (+ 2 a) Scott: λa (+ 2 a) ================================================ FILE: tests/snapshots/run_file__lam_op2_nested.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/lam_op2_nested.bend --- NumScott: λa (+ (* a a) (+ 3 (+ 2 a))) Scott: λa (+ (* a a) (+ 3 (+ 2 a))) ================================================ FILE: tests/snapshots/run_file__let_tup_readback.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/let_tup_readback.bend --- NumScott: Warnings: During readback: Unable to interpret the HVM result as a valid Bend term. (Reached Root) λa ($b (a λc ( λ$b c))) Scott: Warnings: During readback: Unable to interpret the HVM result as a valid Bend term. (Reached Root) λa ($b (a λc ( λ$b c))) ================================================ FILE: tests/snapshots/run_file__linearize_match.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/linearize_match.bend --- NumScott: λa switch a = a { 0: λb b; _: λd (+ a-1 d); } Scott: λa switch a = a { 0: λb b; _: λd (+ a-1 d); } ================================================ FILE: tests/snapshots/run_file__list_resugar.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/list_resugar.bend --- NumScott: [42, [λd d]] Scott: [42, [λd d]] ================================================ FILE: tests/snapshots/run_file__list_reverse.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/list_reverse.bend --- NumScott: λa (a list/cons/tag 1 λb (b list/cons/tag 2 λc (c list/cons/tag 3 list/nil))) Scott: λa λ* (a 1 λb λ* (b 2 λc λ* (c 3 list/nil))) ================================================ FILE: tests/snapshots/run_file__list_reverse_imp.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/list_reverse_imp.bend --- NumScott: [1, 2, 3, 4, 5] Scott: [1, 2, 3, 4, 5] ================================================ FILE: tests/snapshots/run_file__list_take.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/list_take.bend --- NumScott: [3, 2] Scott: [3, 2] ================================================ FILE: tests/snapshots/run_file__list_to_tree.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/list_to_tree.bend --- NumScott: {{1 2} {3 {4 5}}} Scott: {{1 2} {3 {4 5}}} ================================================ FILE: tests/snapshots/run_file__mapper_syntax.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/mapper_syntax.bend --- NumScott: (2, (10, 3)) Scott: (2, (10, 3)) ================================================ FILE: tests/snapshots/run_file__match.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/match.bend --- NumScott: λ* λa a Scott: λ* λa a ================================================ FILE: tests/snapshots/run_file__match_builtins.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/match_builtins.bend --- NumScott: {"ello" "world"} Scott: {"ello" "world"} ================================================ FILE: tests/snapshots/run_file__match_mult_linearization.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/match_mult_linearization.bend --- NumScott: λa switch a = a { 0: λb λc λd (+ (+ b c) d); _: λf λg λh (+ (+ (+ a-1 f) g) h); } Scott: λa switch a = a { 0: λb λc λd (+ (+ b c) d); _: λf λg λh (+ (+ (+ a-1 f) g) h); } ================================================ FILE: tests/snapshots/run_file__match_num_adt_tup_parser.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/match_num_adt_tup_parser.bend --- NumScott: λa (a Result_/Err/tag {"(+" *}) Scott: λ* λa (a {"(+" *}) ================================================ FILE: tests/snapshots/run_file__match_num_explicit_bind.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/match_num_explicit_bind.bend --- NumScott: 3 Scott: 3 ================================================ FILE: tests/snapshots/run_file__match_num_num_to_char.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/match_num_num_to_char.bend --- NumScott: {{[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16777215]} [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 0]} Scott: {{[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16777215]} [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 0]} ================================================ FILE: tests/snapshots/run_file__match_num_succ_complex.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/match_num_succ_complex.bend --- NumScott: [[5, 5, *, *, *, *], [5, 5, *, *, *, *]] Scott: [[5, 5, *, *, *, *], [5, 5, *, *, *, *]] ================================================ FILE: tests/snapshots/run_file__match_str.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/match_str.bend --- NumScott: [2, 2, 1, 0, 0, 0] Scott: [2, 2, 1, 0, 0, 0] ================================================ FILE: tests/snapshots/run_file__match_sup.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/match_sup.bend --- Errors: In tests/golden_tests/run_file/match_sup.bend : - expected: term - detected: end of input  7 |   ================================================ FILE: tests/snapshots/run_file__match_vars.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/match_vars.bend --- Errors: In tests/golden_tests/run_file/match_vars.bend : In definition 'main': Irrefutable 'match' expression. All cases after variable pattern 'true' will be ignored. Note that to use a 'match' expression, the matched constructors need to be defined in a 'data' definition. If this is not a mistake, consider using a 'let' expression instead. ================================================ FILE: tests/snapshots/run_file__math.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/math.bend --- NumScott: [0.500, 0.866, 0.577, 1.732, 1.155, 2.000, 0.551, 1.020, 0.482, 1.176, 0.785, 1.571, 3.000, 10.000, 9.000, -8.000, -9.000, 1.000, 1.000, 0.000, 0.000, 6.000, 6.000, 5.000] Scott: [0.500, 0.866, 0.577, 1.732, 1.155, 2.000, 0.551, 1.020, 0.482, 1.176, 0.785, 1.571, 3.000, 10.000, 9.000, -8.000, -9.000, 1.000, 1.000, 0.000, 0.000, 6.000, 6.000, 5.000] ================================================ FILE: tests/snapshots/run_file__merge_sort.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/merge_sort.bend --- NumScott: 120 Scott: 120 ================================================ FILE: tests/snapshots/run_file__mixed_syntax.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/mixed_syntax.bend --- NumScott: Bool/False Scott: Bool/False ================================================ FILE: tests/snapshots/run_file__names_hyphen.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/names_hyphen.bend --- NumScott: 1 Scott: 1 ================================================ FILE: tests/snapshots/run_file__names_hyphen_toplevel.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/names_hyphen_toplevel.bend --- NumScott: λa (a λb (b Foo-Bar/Baz-Qux/tag 1) fun-with-hyphen) Scott: λa (a λb (b 1) fun-with-hyphen) ================================================ FILE: tests/snapshots/run_file__nat_add.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/nat_add.bend --- Errors: In tests/golden_tests/run_file/nat_add.bend : - expected: term - detected: end of input  5 |   ================================================ FILE: tests/snapshots/run_file__nat_add_num.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/nat_add_num.bend --- Errors: In tests/golden_tests/run_file/nat_add_num.bend : - expected: term - detected: end of input  5 |   ================================================ FILE: tests/snapshots/run_file__nested_list_and_string.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/nested_list_and_string.bend --- NumScott: λa [a, λ* 2, λe (e String/Cons/tag [7, "1234", 9] λm (m String/Cons/tag a λn (n String/Cons/tag * "42")))] Scott: λa [a, λ* 2, λ* λe (e [7, "1234", 9] λ* λm (m a λ* λn (n * "42")))] ================================================ FILE: tests/snapshots/run_file__nested_map_get.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/nested_map_get.bend --- NumScott: 43 Scott: 43 ================================================ FILE: tests/snapshots/run_file__nested_map_set.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/nested_map_set.bend --- NumScott: 100 Scott: 100 ================================================ FILE: tests/snapshots/run_file__nested_str.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/nested_str.bend --- NumScott: (λa (a String/Cons/tag "a" ""), (λc (c String/Cons/tag 97 λd (d String/Cons/tag "bc" "")), (λg (g String/Cons/tag "ab" "c"), λk (k String/Cons/tag "ab" λn (n String/Cons/tag "cd" ""))))) Scott: (λ* λa (a "a" ""), (λ* λc (c 97 λ* λd (d "bc" "")), (λ* λg (g "ab" "c"), λ* λk (k "ab" λ* λn (n "cd" ""))))) ================================================ FILE: tests/snapshots/run_file__num_cast.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/num_cast.bend --- NumScott: (16777215, (1, (0, (400, (1, (1, (0, (0, (16777215, (0, (0, (99999, (+0, (+1, (+123456, (+1, (+1, (-3, (-3, (+8388607, (-8388608, (+0, (99999, (0.000, (1.000, (123456.000, (-1.000, (1.000, (0.000, 400.000))))))))))))))))))))))))))))) Scott: (16777215, (1, (0, (400, (1, (1, (0, (0, (16777215, (0, (0, (99999, (+0, (+1, (+123456, (+1, (+1, (-3, (-3, (+8388607, (-8388608, (+0, (99999, (0.000, (1.000, (123456.000, (-1.000, (1.000, (0.000, 400.000))))))))))))))))))))))))))))) ================================================ FILE: tests/snapshots/run_file__num_match_missing_var.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/num_match_missing_var.bend --- Errors: In tests/golden_tests/run_file/num_match_missing_var.bend : - expected: '}' - detected:  7 | _: f ================================================ FILE: tests/snapshots/run_file__num_pred.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/num_pred.bend --- NumScott: 42 Scott: 42 ================================================ FILE: tests/snapshots/run_file__open.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/open.bend --- NumScott: {λa (a State/new/tag 1 2) 1} Scott: {λa (a 1 2) 1} ================================================ FILE: tests/snapshots/run_file__open_object.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/open_object.bend --- NumScott: 1 Scott: 1 ================================================ FILE: tests/snapshots/run_file__open_too_many_ctrs.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/open_too_many_ctrs.bend --- Errors: In tests/golden_tests/run_file/open_too_many_ctrs.bend : In definition 'main': Type 'MyTree' of an 'open' has more than one constructor ================================================ FILE: tests/snapshots/run_file__open_undefined_type.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/open_undefined_type.bend --- Errors: In tests/golden_tests/run_file/open_undefined_type.bend : In definition 'main': Type 'MyType' of an 'open' is not defined ================================================ FILE: tests/snapshots/run_file__ops.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/ops.bend --- NumScott: [1, 1, 1, 1, 1, 1, 1, 1] Scott: [1, 1, 1, 1, 1, 1, 1, 1] ================================================ FILE: tests/snapshots/run_file__override_list_ctr.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/override_list_ctr.bend --- Errors: In tests/golden_tests/run_file/override_list_ctr.bend : Redefinition of builtin (constructor) 'List/Nil'. Location:  1 | List/Nil = * ================================================ FILE: tests/snapshots/run_file__override_str_ctr.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/override_str_ctr.bend --- Errors: In tests/golden_tests/run_file/override_str_ctr.bend : Redefinition of builtin (constructor) 'String/Cons'. Location:  1 | String/Cons = * ================================================ FILE: tests/snapshots/run_file__pred.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/pred.bend --- NumScott: 2 Scott: 2 ================================================ FILE: tests/snapshots/run_file__queue.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/queue.bend --- NumScott: λa λ* (a 1 λb λ* (b 2 λc λ* (c 3 Nil))) Scott: λa λ* (a 1 λb λ* (b 2 λc λ* (c 3 Nil))) ================================================ FILE: tests/snapshots/run_file__radix_sort_ctr.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/radix_sort_ctr.bend --- NumScott: 120 Scott: 120 ================================================ FILE: tests/snapshots/run_file__readback_hvm1_main.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/readback_hvm1_main.bend --- Errors: In definition 'Main': Main definition can't be referenced inside the program. ================================================ FILE: tests/snapshots/run_file__readback_list_other_ctr.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/readback_list_other_ctr.bend --- NumScott: λa (a List/Cons/tag λb (b String/Cons/tag 97 λc (c tup/pair/tag 98 "c")) λe (e List/Cons/tag 1 λf (f tup/pair/tag 2 [3, 4]))) Scott: λ* λa (a λ* λb (b 97 λc (c 98 "c")) λ* λe (e 1 λf (f 2 [3, 4]))) ================================================ FILE: tests/snapshots/run_file__readback_num_ops.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/readback_num_ops.bend --- NumScott: [λb (+ 1 b), λd (+ 1 d), λf λg (+ f g), λi (- i 1), λk (- 1 k), λm λn λo (+ m (- n o)), λq λr λs (+ (- q r) s)] Scott: [λb (+ 1 b), λd (+ 1 d), λf λg (+ f g), λi (- i 1), λk (- 1 k), λm λn λo (+ m (- n o)), λq λr λs (+ (- q r) s)] ================================================ FILE: tests/snapshots/run_file__recursive_bind.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/recursive_bind.bend --- NumScott: λa (a Result/Err/tag 0) Scott: λ* λa (a 0) ================================================ FILE: tests/snapshots/run_file__recursive_combinator.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/recursive_combinator.bend --- NumScott: 0 Scott: 0 ================================================ FILE: tests/snapshots/run_file__recursive_combinator_nested.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/recursive_combinator_nested.bend --- Errors: In tests/golden_tests/run_file/recursive_combinator_nested.bend : - expected: term - detected:  4 | _: a-1 ================================================ FILE: tests/snapshots/run_file__recursive_match_native.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/recursive_match_native.bend --- NumScott: 512 Scott: 512 ================================================ FILE: tests/snapshots/run_file__ref_resolution.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/ref_resolution.bend --- NumScott: 42 Scott: 42 ================================================ FILE: tests/snapshots/run_file__repeated_name_truncation.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/repeated_name_truncation.bend --- NumScott: λ* long_name_that_truncates2 Scott: λ* long_name_that_truncates2 ================================================ FILE: tests/snapshots/run_file__scopeless_discard.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/scopeless_discard.bend --- NumScott: {2 *} Scott: {2 *} ================================================ FILE: tests/snapshots/run_file__str_concat.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/str_concat.bend --- NumScott: "hello world" Scott: "hello world" ================================================ FILE: tests/snapshots/run_file__str_inc.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/str_inc.bend --- Errors: In tests/golden_tests/run_file/str_inc.bend : - expected: ')' - detected:  3 | (StrGo 0 str) = str ================================================ FILE: tests/snapshots/run_file__str_inc_eta.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/str_inc_eta.bend --- Errors: In tests/golden_tests/run_file/str_inc_eta.bend : - expected: ')' - detected:  3 | (StrGo 0 (head, tail)) = (head, tail) ================================================ FILE: tests/snapshots/run_file__str_len.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/str_len.bend --- NumScott: 4 Scott: 4 ================================================ FILE: tests/snapshots/run_file__strict_monad_fn.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/strict_monad_fn.bend --- NumScott: λa (a Result/Err/tag 1) Scott: λ* λa (a 1) ================================================ FILE: tests/snapshots/run_file__sum_tree.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/sum_tree.bend --- NumScott: 256 Scott: 256 ================================================ FILE: tests/snapshots/run_file__sup_app.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/sup_app.bend --- NumScott: {3 3} Scott: {3 3} ================================================ FILE: tests/snapshots/run_file__sup_reconstruction.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/sup_reconstruction.bend --- NumScott: λa a Scott: λa a ================================================ FILE: tests/snapshots/run_file__superposed_is_even.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/superposed_is_even.bend --- NumScott: {{MyBool/T MyBool/F} {MyBool/T MyBool/F}} Scott: {{MyBool/T MyBool/F} {MyBool/T MyBool/F}} ================================================ FILE: tests/snapshots/run_file__tagged_lam.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/tagged_lam.bend --- Errors: In tests/golden_tests/run_file/tagged_lam.bend : - expected: term - detected: end of input  2 |   ================================================ FILE: tests/snapshots/run_file__tree_to_list.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/tree_to_list.bend --- NumScott: [4, 3, 2, 1] Scott: [4, 3, 2, 1] ================================================ FILE: tests/snapshots/run_file__tup_list_strings.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/tup_list_strings.bend --- NumScott: {[{"foo" 0}, {"foo" 0}, {"foo" 1}] 4} Scott: {[{"foo" 0}, {"foo" 0}, {"foo" 1}] 4} ================================================ FILE: tests/snapshots/run_file__tup_reconstruction.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/tup_reconstruction.bend --- NumScott: λa a Scott: λa a ================================================ FILE: tests/snapshots/run_file__tuple_eta.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/tuple_eta.bend --- NumScott: (10.000, 10.000) Scott: (10.000, 10.000) ================================================ FILE: tests/snapshots/run_file__tuple_rots.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/tuple_rots.bend --- NumScott: λa (a 5 6 7 8 1 2 3 4) Scott: λa (a 5 6 7 8 1 2 3 4) ================================================ FILE: tests/snapshots/run_file__unaplied_str.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/unaplied_str.bend --- NumScott: λa λb λc (c String/Cons/tag a λd (d String/Cons/tag 98 λe (e String/Cons/tag 99 λf (f String/Cons/tag b "")))) Scott: λa λb λ* λc (c a λ* λd (d 98 λ* λe (e 99 λ* λf (f b "")))) ================================================ FILE: tests/snapshots/run_file__unbound_wrap.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/unbound_wrap.bend --- Errors: In tests/golden_tests/run_file/unbound_wrap.bend : In definition 'main': Reference to undefined function 'Maybe_/wrap' ================================================ FILE: tests/snapshots/run_file__unscoped_never_used.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/unscoped_never_used.bend --- Errors: In tests/golden_tests/run_file/unscoped_never_used.bend : In definition 'main': Unscoped variable from lambda 'λ$x' is never used. ================================================ FILE: tests/snapshots/run_file__unused_dup_var.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/unused_dup_var.bend --- NumScott: λa (a X) Scott: λa (a X) ================================================ FILE: tests/snapshots/run_file__unused_main_var.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/unused_main_var.bend --- NumScott: [10, 12, 14, 16] Scott: [10, 12, 14, 16] ================================================ FILE: tests/snapshots/run_file__world.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/world.bend --- NumScott: "🌎" Scott: "🌎" ================================================ FILE: tests/snapshots/run_file__wrong_string.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/run_file/wrong_string.bend --- NumScott: λa (a String/Cons/tag λ* 4 λb (b String/Cons/tag * "")) Scott: λ* λa (a λ* 4 λ* λb (b * "")) ================================================ FILE: tests/snapshots/scott_triggers_unused__test.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/scott_triggers_unused/test.bend --- @bool/f = ((@bool/f/tag a) a) @bool/f/tag = 1 @bool/t = ((@bool/t/tag a) a) @bool/t/tag = 0 @main = (((?((0 (* 1)) a) a) b) b) ================================================ FILE: tests/snapshots/simplify_matches__adt_tup_era.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/simplify_matches/adt_tup_era.bend --- unchecked Foo: Any (Foo) = λa match a { Tuple/Pair b c: (match b { Tuple/Pair d e: λf d; } c); } unchecked Main: Any (Main) = (Foo (Tuple/Pair 1 5)) Tuple/Pair/tag: _ (Tuple/Pair/tag) = 0 Tuple/Pair: (Any -> Any -> Tuple) (Tuple/Pair) = λa λb λc (c Tuple/Pair/tag a b) Warnings: In tests/golden_tests/simplify_matches/adt_tup_era.bend : In definition 'Foo': Unreachable pattern matching rule '(Foo *)' (rule index 1). ================================================ FILE: tests/snapshots/simplify_matches__already_flat.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/simplify_matches/already_flat.bend --- unchecked Rule1: Any (Rule1) = λa a unchecked Rule2: Any (Rule2) = λa λb b unchecked Rule3: Any (Rule3) = λa λb λc λd (a b c d) unchecked Rule4: Any (Rule4) = λa match a { Foo/CtrA: λb b; Foo/CtrB c: c; } unchecked Rule5: Any (Rule5) = λa match a { Bar/CtrA1 b: λc let d = c; (b d); Bar/CtrA2 e f: λg let h = g; (e f h); Bar/CtrA3 i: λj let k = j; (match k { Baz/CtrB0: λl (Bar/CtrA3 l); Baz/CtrB1 m: λn (Bar/CtrA3 n m); Baz/CtrB2 o: λp (Bar/CtrA3 p (Baz/CtrB2 o)); Baz/CtrB3 q: λr (r q); } i); } unchecked Rule6: Any (Rule6) = λa a Foo/CtrA/tag: _ (Foo/CtrA/tag) = 0 Foo/CtrA: Foo (Foo/CtrA) = λa (a Foo/CtrA/tag) Foo/CtrB/tag: _ (Foo/CtrB/tag) = 1 Foo/CtrB: (Any -> Foo) (Foo/CtrB) = λa λb (b Foo/CtrB/tag a) Bar/CtrA1/tag: _ (Bar/CtrA1/tag) = 0 Bar/CtrA1: (Any -> Bar) (Bar/CtrA1) = λa λb (b Bar/CtrA1/tag a) Bar/CtrA2/tag: _ (Bar/CtrA2/tag) = 1 Bar/CtrA2: (Any -> Any -> Bar) (Bar/CtrA2) = λa λb λc (c Bar/CtrA2/tag a b) Bar/CtrA3/tag: _ (Bar/CtrA3/tag) = 2 Bar/CtrA3: (Any -> Bar) (Bar/CtrA3) = λa λb (b Bar/CtrA3/tag a) Baz/CtrB0/tag: _ (Baz/CtrB0/tag) = 0 Baz/CtrB0: Baz (Baz/CtrB0) = λa (a Baz/CtrB0/tag) Baz/CtrB1/tag: _ (Baz/CtrB1/tag) = 1 Baz/CtrB1: (Any -> Baz) (Baz/CtrB1) = λa λb (b Baz/CtrB1/tag a) Baz/CtrB2/tag: _ (Baz/CtrB2/tag) = 2 Baz/CtrB2: (Any -> Baz) (Baz/CtrB2) = λa λb (b Baz/CtrB2/tag a) Baz/CtrB3/tag: _ (Baz/CtrB3/tag) = 3 Baz/CtrB3: (Any -> Baz) (Baz/CtrB3) = λa λb (b Baz/CtrB3/tag a) Warnings: In tests/golden_tests/simplify_matches/already_flat.bend : In definition 'Rule4': Unreachable pattern matching rule '(Rule4 x)' (rule index 2). In definition 'Rule6': Unreachable pattern matching rule '(Rule6 b)' (rule index 1). ================================================ FILE: tests/snapshots/simplify_matches__bits_dec.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/simplify_matches/bits_dec.bend --- unchecked Data.Bits.dec: Any (Data.Bits.dec) = λa match a { Data/Bits/e: Data/Bits/e; Data/Bits/o b: match b { Data/Bits/e: Data/Bits/e; Data/Bits/o c: (Data/Bits/i (Data.Bits.dec c)); Data/Bits/i d: (Data/Bits/i (Data.Bits.dec d)); }; Data/Bits/i e: match e { Data/Bits/e: (Data/Bits/o Data/Bits/e); Data/Bits/o f: (Data/Bits/o f); Data/Bits/i g: (Data/Bits/o g); }; } Data/Bits/e/tag: _ (Data/Bits/e/tag) = 0 Data/Bits/e: Data/Bits (Data/Bits/e) = λa (a Data/Bits/e/tag) Data/Bits/o/tag: _ (Data/Bits/o/tag) = 1 Data/Bits/o: (Any -> Data/Bits) (Data/Bits/o) = λa λb (b Data/Bits/o/tag a) Data/Bits/i/tag: _ (Data/Bits/i/tag) = 2 Data/Bits/i: (Any -> Data/Bits) (Data/Bits/i) = λa λb (b Data/Bits/i/tag a) ================================================ FILE: tests/snapshots/simplify_matches__complex_with_case.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/simplify_matches/complex_with_case.bend --- unchecked map: Any (map) = λa λb (match b { Tree_/Node c d e f: λg (Tree_/Node (map g c) (map g d) (map g e) (map g f)); Tree_/Leaf h: λi (Tree_/Leaf (i h)); } a) unchecked main: Any (main) = map Tree_/Node/tag: _ (Tree_/Node/tag) = 0 Tree_/Node: (Any -> Any -> Any -> Any -> Tree_) (Tree_/Node) = λa λb λc λd λe (e Tree_/Node/tag a b c d) Tree_/Leaf/tag: _ (Tree_/Leaf/tag) = 1 Tree_/Leaf: (Any -> Tree_) (Tree_/Leaf) = λa λb (b Tree_/Leaf/tag a) ================================================ FILE: tests/snapshots/simplify_matches__double_unwrap_box.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/simplify_matches/double_unwrap_box.bend --- unchecked DoubleUnbox: Any (DoubleUnbox) = λa match a { Boxed/Box b: match b { Boxed/Box c: λd let e = d; let f = e; c; }; } unchecked Main: Any (Main) = (DoubleUnbox (Boxed/Box (Boxed/Box 0)) 5) Boxed/Box/tag: _ (Boxed/Box/tag) = 0 Boxed/Box: (Any -> Boxed) (Boxed/Box) = λa λb (b Boxed/Box/tag a) Warnings: In tests/golden_tests/simplify_matches/double_unwrap_box.bend : In definition 'DoubleUnbox': Unreachable pattern matching rule '(DoubleUnbox * x)' (rule index 1). ================================================ FILE: tests/snapshots/simplify_matches__double_unwrap_maybe.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/simplify_matches/double_unwrap_maybe.bend --- unchecked DoubleUnwrap: Any (DoubleUnwrap) = λa match a { Maybe_/Some b: match b { Maybe_/Some c: λd let e = d; let f = e; c; Maybe_/None: λg let h = g; let i = h; i; }; Maybe_/None: λj let k = j; k; } unchecked Main: Any (Main) = (DoubleUnwrap (Maybe_/Some Maybe_/None) 5) Maybe_/Some/tag: _ (Maybe_/Some/tag) = 0 Maybe_/Some: (Any -> Maybe_) (Maybe_/Some) = λa λb (b Maybe_/Some/tag a) Maybe_/None/tag: _ (Maybe_/None/tag) = 1 Maybe_/None: Maybe_ (Maybe_/None) = λa (a Maybe_/None/tag) ================================================ FILE: tests/snapshots/simplify_matches__flatten_with_terminal.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/simplify_matches/flatten_with_terminal.bend --- unchecked Foo: Any (Foo) = λa switch a { 0: λb let c = b; match c { A_t/A d: match d { B_t/B: B_t/B; }; }; _ e: λf let g = f; *; } unchecked main: Any (main) = (Foo 2 (A_t/A B_t/B)) A_t/A/tag: _ (A_t/A/tag) = 0 A_t/A: (Any -> A_t) (A_t/A) = λa λb (b A_t/A/tag a) B_t/B/tag: _ (B_t/B/tag) = 0 B_t/B: B_t (B_t/B) = λa (a B_t/B/tag) ================================================ FILE: tests/snapshots/simplify_matches__irrefutable_case.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/simplify_matches/irrefutable_case.bend --- unchecked l: Any (l) = 1001 unchecked v1: Any (v1) = l unchecked v2: Any (v2) = l unchecked v3: Any (v3) = 2002 unchecked v4: Any (v4) = 3003 unchecked v5: Any (v5) = (λa a 5005) unchecked main: Any (main) = (v1, v2, v3, v4, v5) Warnings: In tests/golden_tests/simplify_matches/irrefutable_case.bend : In definition 'v1': Irrefutable 'match' expression. All cases after variable pattern 'x' will be ignored. Note that to use a 'match' expression, the matched constructors need to be defined in a 'data' definition. If this is not a mistake, consider using a 'let' expression instead. In definition 'v2': Irrefutable 'match' expression. All cases after variable pattern 'x' will be ignored. Note that to use a 'match' expression, the matched constructors need to be defined in a 'data' definition. If this is not a mistake, consider using a 'let' expression instead. In definition 'v3': Irrefutable 'match' expression. All cases after variable pattern 'x' will be ignored. Note that to use a 'match' expression, the matched constructors need to be defined in a 'data' definition. If this is not a mistake, consider using a 'let' expression instead. In definition 'v4': Irrefutable 'match' expression. All cases after variable pattern 'x' will be ignored. Note that to use a 'match' expression, the matched constructors need to be defined in a 'data' definition. If this is not a mistake, consider using a 'let' expression instead. In definition 'v5': Irrefutable 'match' expression. All cases after variable pattern 'x' will be ignored. Note that to use a 'match' expression, the matched constructors need to be defined in a 'data' definition. If this is not a mistake, consider using a 'let' expression instead. ================================================ FILE: tests/snapshots/simplify_matches__linearize_match_all.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/simplify_matches/linearize_match_all.bend --- unchecked A: Any (A) = λa switch a { 0: λb λc (b c); _ d: λe λf (d e f); } unchecked B: Any (B) = λa λb λc (switch c { 0: λd λe (d e); _ f: λg λh (g h f); } a b) unchecked C: Any (C) = λa λb λc switch c { 0: (a b); _ d: (a b d); } unchecked D: Any (D) = λa switch a { 0: λb λc c; _ d: λe λf (d f); } unchecked E: Any (E) = λa match a { ConsList/Cons b c: λd let e = d; (match e { ConsList/Cons f g: λh λi (h i f g); ConsList/Nil: λj λk (ConsList/Cons j k ConsList/Nil); } b c); ConsList/Nil: λl let m = l; (ConsList/Nil m); } unchecked A2: Any (A2) = λa match a { ConsList/Cons b c: λd λe (b c d e); ConsList/Nil: λf λg (f g); } unchecked B2: Any (B2) = λa λb λc (match c { ConsList/Cons d e: λf λg (f g d e); ConsList/Nil: λh λi (h i); } a b) unchecked C2: Any (C2) = λa λb λc match c { ConsList/Cons d e: (a b d e); ConsList/Nil: (a b); } unchecked D2: Any (D2) = λa match a { ConsList/Cons b c: λd λe (b c d e); ConsList/Nil: λf λg (f g); } unchecked main: Any (main) = * ConsList/Cons/tag: _ (ConsList/Cons/tag) = 0 ConsList/Cons: (Any -> Any -> ConsList) (ConsList/Cons) = λa λb λc (c ConsList/Cons/tag a b) ConsList/Nil/tag: _ (ConsList/Nil/tag) = 1 ConsList/Nil: ConsList (ConsList/Nil) = λa (a ConsList/Nil/tag) ================================================ FILE: tests/snapshots/simplify_matches__match_str.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/simplify_matches/match_str.bend --- unchecked is_as: Any (is_as) = λa match a { String/Nil: 1; String/Cons b c: (switch (- b 65) { 0: λd match d { String/Nil: 0; String/Cons e f: (switch (- e 115) { 0: λg match g { String/Nil: 2; String/Cons h i: 0; }; _ j: λk 0; } f); }; _ l: λm (switch (- l 31) { 0: λn match n { String/Nil: 0; String/Cons o p: (switch (- o 115) { 0: λq match q { String/Nil: 2; String/Cons r s: 0; }; _ t: λu 0; } p); }; _ v: λw 0; } m); } c); } unchecked main: Any (main) = * ================================================ FILE: tests/snapshots/simplify_matches__nested.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/simplify_matches/nested.bend --- unchecked Rule: Any (Rule) = λa match a { Foo/CtrA b c: (match c { Bar/CtrB1 d: λe (e d); Bar/CtrB2 f g: λh (match f { Baz/CtrC: λi λj (i j); } h g); } b); Foo/CtrB k: k; } Foo/CtrA/tag: _ (Foo/CtrA/tag) = 0 Foo/CtrA: (Any -> Any -> Foo) (Foo/CtrA) = λa λb λc (c Foo/CtrA/tag a b) Foo/CtrB/tag: _ (Foo/CtrB/tag) = 1 Foo/CtrB: (Any -> Foo) (Foo/CtrB) = λa λb (b Foo/CtrB/tag a) Bar/CtrB1/tag: _ (Bar/CtrB1/tag) = 0 Bar/CtrB1: (Any -> Bar) (Bar/CtrB1) = λa λb (b Bar/CtrB1/tag a) Bar/CtrB2/tag: _ (Bar/CtrB2/tag) = 1 Bar/CtrB2: (Any -> Any -> Bar) (Bar/CtrB2) = λa λb λc (c Bar/CtrB2/tag a b) Baz/CtrC/tag: _ (Baz/CtrC/tag) = 0 Baz/CtrC: Baz (Baz/CtrC) = λa (a Baz/CtrC/tag) Warnings: In tests/golden_tests/simplify_matches/nested.bend : In definition 'Rule': Unreachable pattern matching rule '(Rule (Foo/CtrA a b))' (rule index 2). Unreachable pattern matching rule '(Rule x)' (rule index 4). ================================================ FILE: tests/snapshots/simplify_matches__nested2.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/simplify_matches/nested2.bend --- unchecked Foo: Any (Foo) = λa λb (match b { List/Nil: λc (c List/Nil); List/Cons d e: λf (match e { List/Nil: λg λh (g (List/Cons h List/Nil)); List/Cons i j: λk λl (k l i j); } f d); } a) List/Nil/tag: _ (List/Nil/tag) = 0 List/Nil: (List T) (List/Nil) = λa (a List/Nil/tag) List/Cons/tag: _ (List/Cons/tag) = 1 List/Cons: (T -> (List T) -> (List T)) (List/Cons) = λa λb λc (c List/Cons/tag a b) ================================================ FILE: tests/snapshots/simplify_matches__nested_0ary.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/simplify_matches/nested_0ary.bend --- unchecked Unpack: Any (Unpack) = λa λb (match b { list/Cons c d: λe (match d { list/Cons f g: λh λi (h (list/Cons i (list/Cons f g))); list/Nil: λj λk k; } e c); list/Nil: λl list/Nil; } a) list/Cons/tag: _ (list/Cons/tag) = 0 list/Cons: (Any -> Any -> list) (list/Cons) = λa λb λc (c list/Cons/tag a b) list/Nil/tag: _ (list/Nil/tag) = 1 list/Nil: list (list/Nil) = λa (a list/Nil/tag) ================================================ FILE: tests/snapshots/simplify_matches__redundant_with_era.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/simplify_matches/redundant_with_era.bend --- unchecked Fn2: Any (Fn2) = λa switch a { 0: λb let c = b; let (d, e) = c; let (f, g) = e; g; _ h: λi let j = i; let (k, l) = j; let (m, n) = l; n; } unchecked main: Any (main) = * Warnings: In tests/golden_tests/simplify_matches/redundant_with_era.bend : In definition 'Fn2': Unreachable pattern matching rule '(Fn2 0 *)' (rule index 1). Unreachable pattern matching rule '(Fn2 a *)' (rule index 2). ================================================ FILE: tests/snapshots/simplify_matches__wrong_fn_arity.bend.snap ================================================ --- source: tests/golden_tests.rs input_file: tests/golden_tests/simplify_matches/wrong_fn_arity.bend --- Errors: In tests/golden_tests/simplify_matches/wrong_fn_arity.bend : In definition 'Foo': Incorrect pattern matching rule arity. Expected 3 args, found 0.