From 3c4d705aa5102f90e2d1c8473870f73bfb07c777 Mon Sep 17 00:00:00 2001
From: Maxime Buyse <maxime@cryspen.com>
Date: Wed, 24 Jul 2024 09:17:23 +0200
Subject: [PATCH 1/2] Fix potentially looping predicate_id.

---
 frontend/exporter/src/traits.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/frontend/exporter/src/traits.rs b/frontend/exporter/src/traits.rs
index 67d7cd47c..6e58c335f 100644
--- a/frontend/exporter/src/traits.rs
+++ b/frontend/exporter/src/traits.rs
@@ -8,11 +8,13 @@ pub enum ImplExprPathChunk {
     AssocItem {
         item: AssocItem,
         predicate: Binder<TraitPredicate>,
+        #[value(predicate.predicate_id(tcx))]
         predicate_id: PredicateId,
         index: usize,
     },
     Parent {
         predicate: Binder<TraitPredicate>,
+        #[value(predicate.predicate_id(tcx))]
         predicate_id: PredicateId,
         index: usize,
     },
@@ -92,12 +94,10 @@ pub mod rustc {
             AssocItem {
                 item: AssocItem,
                 predicate: PolyTraitPredicate<'tcx>,
-                predicate_id: PredicateId,
                 index: usize,
             },
             Parent {
                 predicate: PolyTraitPredicate<'tcx>,
-                predicate_id: PredicateId,
                 index: usize,
             },
         }
@@ -229,7 +229,6 @@ pub mod rustc {
                             cons(
                                 PathChunk::Parent {
                                     predicate: p,
-                                    predicate_id: p.predicate_id(s),
                                     index,
                                 },
                                 path,
@@ -246,7 +245,6 @@ pub mod rustc {
                                         cons(
                                             PathChunk::AssocItem {
                                                 item,
-                                                predicate_id: p.predicate_id(s),
                                                 predicate: p,
                                                 index,
                                             },

From 94124d2c25fe7df0186838f6915005bbb636d4dc Mon Sep 17 00:00:00 2001
From: Maxime Buyse <maxime@cryspen.com>
Date: Wed, 24 Jul 2024 11:54:32 +0200
Subject: [PATCH 2/2] Add block size trait test.

---
 .../toolchain__traits into-fstar.snap         |    20 +
 tests/traits/out                              | 11733 ++++++++++++++++
 tests/traits/src/lib.rs                       |    12 +
 3 files changed, 11765 insertions(+)
 create mode 100644 tests/traits/out

diff --git a/test-harness/src/snapshots/toolchain__traits into-fstar.snap b/test-harness/src/snapshots/toolchain__traits into-fstar.snap
index 81f7fa2f2..d2f3d6240 100644
--- a/test-harness/src/snapshots/toolchain__traits into-fstar.snap	
+++ b/test-harness/src/snapshots/toolchain__traits into-fstar.snap	
@@ -26,6 +26,26 @@ exit = 0
 diagnostics = []
 
 [stdout.files]
+"Traits.Block_size.fst" = '''
+module Traits.Block_size
+#set-options "--fuel 0 --ifuel 1 --z3rlimit 15"
+open Core
+open FStar.Mul
+
+class t_BlockSizeUser (v_Self: Type0) = { f_BlockSize:Type0 }
+
+class t_ParBlocksSizeUser (v_Self: Type0) = {
+  [@@@ FStar.Tactics.Typeclasses.no_method]_super_10960599340086055385:t_BlockSizeUser v_Self
+}
+
+class t_BlockBackend (v_Self: Type0) = {
+  [@@@ FStar.Tactics.Typeclasses.no_method]_super_15949286759387124191:t_ParBlocksSizeUser v_Self;
+  f_proc_block_pre:Alloc.Vec.t_Vec _ Alloc.Alloc.t_Global -> bool;
+  f_proc_block_post:Alloc.Vec.t_Vec _ Alloc.Alloc.t_Global -> Prims.unit -> bool;
+  f_proc_block:x0: Alloc.Vec.t_Vec _ Alloc.Alloc.t_Global
+    -> Prims.Pure Prims.unit (f_proc_block_pre x0) (fun result -> f_proc_block_post x0 result)
+}
+'''
 "Traits.For_clauses.Issue_495_.Minimized_3_.fst" = '''
 module Traits.For_clauses.Issue_495_.Minimized_3_
 #set-options "--fuel 0 --ifuel 1 --z3rlimit 15"
diff --git a/tests/traits/out b/tests/traits/out
new file mode 100644
index 000000000..6ca130f3e
--- /dev/null
+++ b/tests/traits/out
@@ -0,0 +1,11733 @@
+   Compiling traits v0.1.0 (/home/maxime/cryspen/hax/tests/traits)
+┐predicate_id self=Binder { value: TraitPredicate(<Self as std::clone::Clone>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<Self as std::clone::Clone>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as SuperTrait>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::clone::Clone>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as SuperTrait>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::clone::Clone>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<Self as std::clone::Clone>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <i32 as std::clone::Clone>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <i32 as std::clone::Clone>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<i32 as std::clone::Clone>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <<() as Foo>::AssocType as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <() as Foo>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <() as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <<() as Foo>::AssocType as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <() as Foo>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <() as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <() as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <() as Foo>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<() as Foo>::AssocType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <() as Foo>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <() as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as Foo>::AssocType as SuperTrait>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <<() as Foo>::AssocType as SuperTrait>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <() as Foo>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <() as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <<() as Foo>::AssocType as SuperTrait>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <() as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <() as Foo>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<() as Foo>::AssocType as SuperTrait>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <() as Foo>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <() as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <() as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <() as Foo>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <T as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <T as Foo>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <T as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <T as Foo>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <T as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <T as Foo>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <T as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <T as Foo>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <T as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <T as Foo>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <T as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <T as Foo>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <<T as Foo>::AssocType as SuperTrait>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <T as Foo>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <T as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <<T as Foo>::AssocType as SuperTrait>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <<T as Foo>::AssocType as SuperTrait>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <<T as Foo>::AssocType as SuperTrait>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐sinto self=AssocItem { item: AssocItem { def_id: DefId(0:6 ~ traits[3797]::Foo::AssocType), name: "AssocType", kind: Type, container: TraitContainer, trait_item_def_id: Some(DefId(0:6 ~ traits[3797]::Foo::AssocType)), fn_has_self_parameter: false, opt_rpitit_info: None }, predicate: Binder { value: TraitPredicate(<<T as Foo>::AssocType as SuperTrait>, polarity:Positive), bound_vars: [] }, index: 0 }2024-07-23T15:13:24.407344Z TRACE impl_expr{self=Binder { value: <<T as Foo>::AssocType as SuperTrait>, bound_vars: [] }}:sinto{self=AssocItem { item: AssocItem { def_id: DefId(0:6 ~ traits[3797]::Foo::AssocType), name: "AssocType", kind: Type, container: TraitContainer, trait_item_def_id: Some(DefId(0:6 ~ traits[3797]::Foo::AssocType)), fn_has_self_parameter: false, opt_rpitit_info: None }, predicate: Binder { value: TraitPredicate(<<T as Foo>::AssocType as SuperTrait>, polarity:Positive), bound_vars: [] }, index: 0 }}: hax_frontend_exporter::traits: frontend/exporter/src/traits.rs:3: Enters sinto (search_clause :: PathChunk < 'tcx >)
+
+│ ├─  0ms TRACE Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ ├─┐impl_expr self=Binder { value: <T as Foo>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <T as Foo>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<<T as Foo>::AssocType as SuperTrait>, polarity:Positive), bound_vars: [] }
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<<T as Foo>::AssocType as SuperTrait>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┐impl_expr self=Binder { value: <T as Foo>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <T as Foo>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+│ │ │ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┐trace_span2 
+│ │ │ │ │ │ ├─┐trace_span3 
+│ │ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ │ ├─┘
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐impl_exprs obligations=[]
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <T as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <T as Foo>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <T as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <T as Foo>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <T as Foo>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <T as Foo>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Foo>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<T as Foo>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as Bar<'a>>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <T as Bar<'_>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <T as Bar<'_>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Bar<'_>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as Bar<'a>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as Bar<'_>>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<T as Bar<'a>>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: ProjectionPredicate(AliasTerm { args: [I/#0], def_id: DefId(2:8504 ~ core[fd5e]::iter::traits::iterator::Iterator::Item) }, Term::Ty(())), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Map<I, {closure@traits/src/lib.rs:57:12: 57:15}> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Map<I, {closure@traits/src/lib.rs:57:12: 57:15}> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: ProjectionPredicate(AliasTerm { args: [Closure(DefId(0:34 ~ traits[3797]::closure_impl_expr::{closure#0}), [I/#0, i16, Binder { value: extern "RustCall" fn(((),)), bound_vars: [] }, ()]), ((),)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(())), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<{closure@traits/src/lib.rs:57:12: 57:15} as std::ops::FnMut<((),)>>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<() as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::ops::FnMut<((),)>>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::ops::FnMut<((),)>>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<()> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<()> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<()> as std::iter::FromIterator<()>>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<()> as std::iter::FromIterator<()>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<() as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Map<I, {closure@traits/src/lib.rs:57:12: 57:15}> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Map<I, {closure@traits/src/lib.rs:57:12: 57:15}> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::ops::FnMut<((),)>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::ops::FnMut<((),)>>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:57:12: 57:15} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: ProjectionPredicate(AliasTerm { args: [I/#0], def_id: DefId(2:8504 ~ core[fd5e]::iter::traits::iterator::Iterator::Item) }, Term::Ty(())), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<F as std::ops::FnMut<((),)>>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <F as std::ops::FnOnce<((),)>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <F as std::ops::FnOnce<((),)>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnOnce<((),)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnOnce<((),)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnOnce<((),)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::ops::FnMut<((),)>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnOnce<((),)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::ops::FnMut<((),)>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::ops::FnMut<((),)>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐sinto self=Parent { predicate: Binder { value: TraitPredicate(<F as std::ops::FnOnce<((),)>>, polarity:Positive), bound_vars: [] }, index: 0 }
+2024-07-23T15:13:24.416280Z TRACE impl_expr{self=Binder { value: <F as std::ops::FnOnce<((),)>>, bound_vars: [] }}:sinto{self=Parent { predicate: Binder { value: TraitPredicate(<F as std::ops::FnOnce<((),)>>, polarity:Positive), bound_vars: [] }, index: 0 }}: hax_frontend_exporter::traits: frontend/exporter/src/traits.rs:3: Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ ├─  0ms TRACE Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::ops::FnOnce<((),)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::ops::FnOnce<((),)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::ops::FnMut<((),)>>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: ProjectionPredicate(AliasTerm { args: [F/#1, ((),)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(())), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <F as std::ops::FnOnce<((),)>>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <F as std::ops::FnOnce<((),)>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnOnce<((),)>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnOnce<((),)>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnOnce<((),)>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::ops::FnMut<((),)>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnOnce<((),)>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::ops::FnMut<((),)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::ops::FnMut<((),)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐sinto self=Parent { predicate: Binder { value: TraitPredicate(<F as std::ops::FnOnce<((),)>>, polarity:Positive), bound_vars: [] }, index: 0 }
+2024-07-23T15:13:24.416991Z TRACE predicate_id{self=Binder { value: ProjectionPredicate(AliasTerm { args: [F/#1, ((),)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(())), bound_vars: [] }}:impl_expr{self=Binder { value: <F as std::ops::FnOnce<((),)>>, bound_vars: [] }}:sinto{self=Parent { predicate: Binder { value: TraitPredicate(<F as std::ops::FnOnce<((),)>>, polarity:Positive), bound_vars: [] }, index: 0 }}: hax_frontend_exporter::traits: frontend/exporter/src/traits.rs:3: Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ │ ├─  0ms TRACE Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::ops::FnOnce<((),)>>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::ops::FnOnce<((),)>>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::ops::FnMut<((),)>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Map<I, F> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Map<I, F> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: ProjectionPredicate(AliasTerm { args: [F/#1, ((),)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(())), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<F as std::ops::FnMut<((),)>>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<() as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <F as std::ops::FnMut<((),)>>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <F as std::ops::FnMut<((),)>>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnMut<((),)>>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnMut<((),)>>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnMut<((),)>>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::ops::FnMut<((),)>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnMut<((),)>>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::ops::FnMut<((),)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<()> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<()> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<()> as std::iter::FromIterator<()>>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<()> as std::iter::FromIterator<()>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<() as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Map<I, F> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Map<I, F> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <F as std::ops::FnMut<((),)>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <F as std::ops::FnMut<((),)>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnMut<((),)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnMut<((),)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnMut<((),)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::ops::FnMut<((),)>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnMut<((),)>>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::ops::FnMut<((),)>>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <() as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<Self as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<Self as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <Self as Lang>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as Lang>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Lang>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as Lang>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Lang>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as Lang>::Var as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as Lang>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as Lang>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Lang>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as Lang>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Lang>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <Self as Lang>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as Lang>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Lang>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as Lang>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Lang>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as Lang>::Var as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as Lang>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as Lang>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Lang>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as Lang>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Lang>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <Self as Lang>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as Lang>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Lang>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as Lang>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as Lang>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <impl FnOnce() -> Error as std::ops::FnOnce<()>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <impl FnOnce() -> Error as std::ops::FnOnce<()>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <impl FnOnce() -> Error as std::ops::FnOnce<()>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::ops::FnOnce<()>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <impl FnOnce() -> Error as std::ops::FnOnce<()>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: ProjectionPredicate(AliasTerm { args: [Alias(Opaque, AliasTy { args: [], def_id: DefId(0:170 ~ traits[3797]::{impl#3}::for_application_callback::{opaque#0}) }), ()], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(Error)), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <impl FnOnce() -> Error as std::ops::FnOnce<()>>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <impl FnOnce() -> Error as std::ops::FnOnce<()>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <impl FnOnce() -> Error as std::ops::FnOnce<()>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::ops::FnOnce<()>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <impl FnOnce() -> Error as std::ops::FnOnce<()>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::ops::FnOnce<()>>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <impl FnOnce() -> Error as std::ops::FnOnce<()>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <impl FnOnce() -> Error as std::ops::FnOnce<()>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <impl FnOnce() -> Error as std::ops::FnOnce<()>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::ops::FnOnce<()>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <impl FnOnce() -> Error as std::ops::FnOnce<()>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: ProjectionPredicate(AliasTerm { args: [Alias(Opaque, AliasTy { args: [], def_id: DefId(0:170 ~ traits[3797]::{impl#3}::for_application_callback::{opaque#0}) }), ()], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(Error)), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <impl FnOnce() -> Error as std::ops::FnOnce<()>>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <impl FnOnce() -> Error as std::ops::FnOnce<()>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <impl FnOnce() -> Error as std::ops::FnOnce<()>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::ops::FnOnce<()>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <impl FnOnce() -> Error as std::ops::FnOnce<()>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::ops::FnOnce<()>>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<impl FnOnce() -> Error as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<X as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<X as for_clauses::Foo<&'a u8>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:53 ~ traits[3797]::for_clauses::_f::'a), 'a))] }
+┘
+┐impl_expr self=Binder { value: <X as for_clauses::Foo<&u8>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <X as for_clauses::Foo<&u8>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<X as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <X as for_clauses::Foo<&u8>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<X as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<X as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<X as for_clauses::Foo<&'a u8>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:53 ~ traits[3797]::for_clauses::_f::'a), 'a))] }, target=Binder { value: <X as for_clauses::Foo<&u8>>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<X as for_clauses::Foo<&'a u8>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:53 ~ traits[3797]::for_clauses::_f::'a), 'a))] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:96:50: 96:53}> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:96:50: 96:53}> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: ProjectionPredicate(AliasTerm { args: [Closure(DefId(0:58 ~ traits[3797]::for_clauses::issue_495::original_function_from_495::{closure#0}), [i16, Binder { value: extern "RustCall" fn((&'^0 u8,)) -> bool, bound_vars: [Region(BrAnon)] }, (&'{erased} std::vec::Vec<u8, std::alloc::Global>,)]), (&'^0 u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrAnon)] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::ops::Range<u8> as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<{closure@traits/src/lib.rs:96:50: 96:53} as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrAnon)] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::ops::Range<u8> as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ │ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐impl_exprs obligations=[]
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrAnon)] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrAnon)] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::iter::FromIterator<u8>>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::iter::FromIterator<u8>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:96:50: 96:53}> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:96:50: 96:53}> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrNamed(DefId(2:55110 ~ core[fd5e]::iter::traits::iterator::Iterator::filter::'_), '_))] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrNamed(DefId(2:55110 ~ core[fd5e]::iter::traits::iterator::Iterator::filter::'_), '_))] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::slice::Iter<'_, u8> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::slice::Iter<'_, u8> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:70: 96:73} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:70: 96:73} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::slice::Iter<'_, u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::slice::Iter<'_, u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:70: 96:73} as std::ops::FnMut<(&u8,)>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:70: 96:73} as std::ops::FnMut<(&u8,)>>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::ops::Deref>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::ops::Deref>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::alloc::Global as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::alloc::Global as std::alloc::Allocator>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::ops::Deref>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::ops::Deref>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::alloc::Global as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::alloc::Global as std::alloc::Allocator>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::ops::Deref>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::ops::Deref>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::alloc::Global as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::alloc::Global as std::alloc::Allocator>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <&u8 as std::cmp::PartialEq>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <&u8 as std::cmp::PartialEq>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::cmp::PartialEq>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::cmp::PartialEq>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::cmp::PartialEq>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:100:27: 100:30}> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:100:27: 100:30}> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: ProjectionPredicate(AliasTerm { args: [Closure(DefId(0:61 ~ traits[3797]::for_clauses::issue_495::minimized_1::{closure#0}), [i16, Binder { value: extern "RustCall" fn((&'^0 u8,)) -> bool, bound_vars: [Region(BrAnon)] }, ()]), (&'^0 u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrAnon)] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::ops::Range<u8> as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<{closure@traits/src/lib.rs:100:27: 100:30} as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrAnon)] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::ops::Range<u8> as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ │ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐impl_exprs obligations=[]
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrAnon)] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrAnon)] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::iter::FromIterator<u8>>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::iter::FromIterator<u8>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:100:27: 100:30}> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:100:27: 100:30}> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrNamed(DefId(2:55110 ~ core[fd5e]::iter::traits::iterator::Iterator::filter::'_), '_))] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrNamed(DefId(2:55110 ~ core[fd5e]::iter::traits::iterator::Iterator::filter::'_), '_))] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Filter<std::ops::Range<u8>, for<'a> fn(&'a u8) -> bool> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Filter<std::ops::Range<u8>, for<'a> fn(&'a u8) -> bool> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: ProjectionPredicate(AliasTerm { args: [Binder { value: fn(&'^0 u8) -> bool, bound_vars: [Region(BrAnon)] }, (&'^0 u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrAnon)] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<for<'a> fn(&'a u8) -> bool as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::ops::Range<u8> as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<for<'a> fn(&'a u8) -> bool as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrAnon)] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::ops::Range<u8> as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ │ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐impl_exprs obligations=[]
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrAnon)] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrAnon)] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::iter::FromIterator<u8>>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::iter::FromIterator<u8>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Filter<std::ops::Range<u8>, for<'a> fn(&'a u8) -> bool> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Filter<std::ops::Range<u8>, for<'a> fn(&'a u8) -> bool> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+disabled backtrace
+warning[E9999]: Hax frontend found a projected type with escaping bound vars. Please report https://github.com/hacspec/hax/issues/495
+                
+                Context:
+                 - alias_ty: AliasTy {
+                    args: [
+                        P/#0,
+                        (&'^0.Named(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), "'_") u8,),
+                    ],
+                    def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output),
+                }
+                 - alias_kind: Projection
+                 - trait_ref: <P as std::ops::FnOnce<(&u8,)>>
+                 - trait_ref_and_generics: (
+                    <P as std::ops::FnOnce<(&u8,)>>,
+                    [],
+                )
+                 - rebased_generics: [
+                    P/#0,
+                    (&'^0.Named(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), "'_") u8,),
+                    (&'^0.Named(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), "'_") u8,),
+                ]
+                 - norm_rebased_generics: Ok(
+                    <P as std::ops::FnOnce<(&u8,)>>,
+                )
+                 - norm_generics: Ok(
+                    <P as std::ops::FnOnce<(&u8,)>>,
+                )
+                 - early_binder_generics: Ok(
+                    <P as std::ops::FnOnce<(&u8,)>>,
+                )
+                 - early_binder_rebased_generics: Ok(
+                    <P as std::ops::FnOnce<(&u8,)>>,
+                )
+   --> traits/src/lib.rs:107:13
+    |
+107 |             impl<P: FnMut(&u8) -> bool> Trait for P {}
+    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    |
+    = note: ⚠️ This is a bug in Hax's frontend.
+            Please report this error to https://github.com/hacspec/hax/issues with some context (e.g. the current crate)!
+
+┐impl_expr self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }, target=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ ├─┘
+├─┘
+├─┐sinto self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }
+2024-07-23T15:13:24.451540Z TRACE impl_expr{self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }}:sinto{self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }}: hax_frontend_exporter::traits: frontend/exporter/src/traits.rs:3: Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ ├─  0ms TRACE Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: ProjectionPredicate(AliasTerm { args: [P/#0, (&'^0.Named(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), "'_") u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+disabled backtrace
+├─┐impl_expr self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }, target=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐sinto self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }
+2024-07-23T15:13:24.452021Z TRACE predicate_id{self=Binder { value: ProjectionPredicate(AliasTerm { args: [P/#0, (&'^0.Named(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), "'_") u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }}:impl_expr{self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }}:sinto{self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }}: hax_frontend_exporter::traits: frontend/exporter/src/traits.rs:3: Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ │ ├─  0ms TRACE Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<X as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<X as for_clauses::Foo<&'a u8>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:53 ~ traits[3797]::for_clauses::_f::'a), 'a))] }
+┘
+┐impl_expr self=Binder { value: <X as for_clauses::Foo<&u8>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <X as for_clauses::Foo<&u8>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<X as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <X as for_clauses::Foo<&u8>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<X as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<X as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<X as for_clauses::Foo<&'a u8>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:53 ~ traits[3797]::for_clauses::_f::'a), 'a))] }, target=Binder { value: <X as for_clauses::Foo<&u8>>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<X as for_clauses::Foo<&'a u8>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:53 ~ traits[3797]::for_clauses::_f::'a), 'a))] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:96:50: 96:53}> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:96:50: 96:53}> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: ProjectionPredicate(AliasTerm { args: [Closure(DefId(0:58 ~ traits[3797]::for_clauses::issue_495::original_function_from_495::{closure#0}), [i16, Binder { value: extern "RustCall" fn((&'^0 u8,)) -> bool, bound_vars: [Region(BrAnon)] }, (&'{erased} std::vec::Vec<u8, std::alloc::Global>,)]), (&'^0 u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrAnon)] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::ops::Range<u8> as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<{closure@traits/src/lib.rs:96:50: 96:53} as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrAnon)] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::ops::Range<u8> as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ │ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐impl_exprs obligations=[]
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrAnon)] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrAnon)] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::iter::FromIterator<u8>>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::iter::FromIterator<u8>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:96:50: 96:53}> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:96:50: 96:53}> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrNamed(DefId(2:55110 ~ core[fd5e]::iter::traits::iterator::Iterator::filter::'_), '_))] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrNamed(DefId(2:55110 ~ core[fd5e]::iter::traits::iterator::Iterator::filter::'_), '_))] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::slice::Iter<'_, u8> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::slice::Iter<'_, u8> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:70: 96:73} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:70: 96:73} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::slice::Iter<'_, u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::slice::Iter<'_, u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:70: 96:73} as std::ops::FnMut<(&u8,)>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:70: 96:73} as std::ops::FnMut<(&u8,)>>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::ops::Deref>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::ops::Deref>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::alloc::Global as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::alloc::Global as std::alloc::Allocator>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::ops::Deref>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::ops::Deref>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::alloc::Global as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::alloc::Global as std::alloc::Allocator>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::ops::Deref>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::ops::Deref>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::alloc::Global as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::alloc::Global as std::alloc::Allocator>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <&u8 as std::cmp::PartialEq>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <&u8 as std::cmp::PartialEq>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::cmp::PartialEq>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::cmp::PartialEq>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::cmp::PartialEq>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:100:27: 100:30}> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:100:27: 100:30}> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: ProjectionPredicate(AliasTerm { args: [Closure(DefId(0:61 ~ traits[3797]::for_clauses::issue_495::minimized_1::{closure#0}), [i16, Binder { value: extern "RustCall" fn((&'^0 u8,)) -> bool, bound_vars: [Region(BrAnon)] }, ()]), (&'^0 u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrAnon)] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::ops::Range<u8> as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<{closure@traits/src/lib.rs:100:27: 100:30} as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrAnon)] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::ops::Range<u8> as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ │ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐impl_exprs obligations=[]
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrAnon)] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrAnon)] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::iter::FromIterator<u8>>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::iter::FromIterator<u8>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:100:27: 100:30}> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:100:27: 100:30}> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrNamed(DefId(2:55110 ~ core[fd5e]::iter::traits::iterator::Iterator::filter::'_), '_))] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrNamed(DefId(2:55110 ~ core[fd5e]::iter::traits::iterator::Iterator::filter::'_), '_))] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Filter<std::ops::Range<u8>, for<'a> fn(&'a u8) -> bool> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Filter<std::ops::Range<u8>, for<'a> fn(&'a u8) -> bool> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: ProjectionPredicate(AliasTerm { args: [Binder { value: fn(&'^0 u8) -> bool, bound_vars: [Region(BrAnon)] }, (&'^0 u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrAnon)] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<for<'a> fn(&'a u8) -> bool as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::ops::Range<u8> as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<for<'a> fn(&'a u8) -> bool as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrAnon)] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::ops::Range<u8> as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ │ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐impl_exprs obligations=[]
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrAnon)] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrAnon)] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::iter::FromIterator<u8>>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::iter::FromIterator<u8>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Filter<std::ops::Range<u8>, for<'a> fn(&'a u8) -> bool> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Filter<std::ops::Range<u8>, for<'a> fn(&'a u8) -> bool> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+disabled backtrace
+┐impl_expr self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }, target=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ ├─┘
+├─┘
+├─┐sinto self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }
+2024-07-23T15:13:24.474758Z TRACE impl_expr{self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }}:sinto{self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }}: hax_frontend_exporter::traits: frontend/exporter/src/traits.rs:3: Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ ├─  0ms TRACE Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: ProjectionPredicate(AliasTerm { args: [P/#0, (&'^0.Named(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), "'_") u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+disabled backtrace
+├─┐impl_expr self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }, target=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐sinto self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }
+2024-07-23T15:13:24.475245Z TRACE predicate_id{self=Binder { value: ProjectionPredicate(AliasTerm { args: [P/#0, (&'^0.Named(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), "'_") u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }}:impl_expr{self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }}:sinto{self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }}: hax_frontend_exporter::traits: frontend/exporter/src/traits.rs:3: Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ │ ├─  0ms TRACE Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:96:50: 96:53}> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:96:50: 96:53}> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: ProjectionPredicate(AliasTerm { args: [Closure(DefId(0:58 ~ traits[3797]::for_clauses::issue_495::original_function_from_495::{closure#0}), [i16, Binder { value: extern "RustCall" fn((&'^0 u8,)) -> bool, bound_vars: [Region(BrAnon)] }, (&'{erased} std::vec::Vec<u8, std::alloc::Global>,)]), (&'^0 u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrAnon)] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::ops::Range<u8> as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<{closure@traits/src/lib.rs:96:50: 96:53} as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrAnon)] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::ops::Range<u8> as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ │ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐impl_exprs obligations=[]
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrAnon)] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrAnon)] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::iter::FromIterator<u8>>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::iter::FromIterator<u8>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:96:50: 96:53}> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:96:50: 96:53}> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrNamed(DefId(2:55110 ~ core[fd5e]::iter::traits::iterator::Iterator::filter::'_), '_))] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrNamed(DefId(2:55110 ~ core[fd5e]::iter::traits::iterator::Iterator::filter::'_), '_))] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::slice::Iter<'_, u8> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::slice::Iter<'_, u8> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:70: 96:73} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:70: 96:73} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::slice::Iter<'_, u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::slice::Iter<'_, u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:70: 96:73} as std::ops::FnMut<(&u8,)>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:70: 96:73} as std::ops::FnMut<(&u8,)>>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::ops::Deref>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::ops::Deref>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::alloc::Global as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::alloc::Global as std::alloc::Allocator>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::ops::Deref>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::ops::Deref>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::alloc::Global as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::alloc::Global as std::alloc::Allocator>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::ops::Deref>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::ops::Deref>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::alloc::Global as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::alloc::Global as std::alloc::Allocator>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <&u8 as std::cmp::PartialEq>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <&u8 as std::cmp::PartialEq>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::cmp::PartialEq>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::cmp::PartialEq>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::cmp::PartialEq>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:96:50: 96:53} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:100:27: 100:30}> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:100:27: 100:30}> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: ProjectionPredicate(AliasTerm { args: [Closure(DefId(0:61 ~ traits[3797]::for_clauses::issue_495::minimized_1::{closure#0}), [i16, Binder { value: extern "RustCall" fn((&'^0 u8,)) -> bool, bound_vars: [Region(BrAnon)] }, ()]), (&'^0 u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrAnon)] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::ops::Range<u8> as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<{closure@traits/src/lib.rs:100:27: 100:30} as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrAnon)] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::ops::Range<u8> as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ │ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐impl_exprs obligations=[]
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrAnon)] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrAnon)] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::iter::FromIterator<u8>>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::iter::FromIterator<u8>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:100:27: 100:30}> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Filter<std::ops::Range<u8>, {closure@traits/src/lib.rs:100:27: 100:30}> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrNamed(DefId(2:55110 ~ core[fd5e]::iter::traits::iterator::Iterator::filter::'_), '_))] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrNamed(DefId(2:55110 ~ core[fd5e]::iter::traits::iterator::Iterator::filter::'_), '_))] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <{closure@traits/src/lib.rs:100:27: 100:30} as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Filter<std::ops::Range<u8>, for<'a> fn(&'a u8) -> bool> as std::iter::Iterator>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Filter<std::ops::Range<u8>, for<'a> fn(&'a u8) -> bool> as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: ProjectionPredicate(AliasTerm { args: [Binder { value: fn(&'^0 u8) -> bool, bound_vars: [Region(BrAnon)] }, (&'^0 u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrAnon)] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<for<'a> fn(&'a u8) -> bool as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::ops::Range<u8> as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=2), Obligation(predicate=Binder { value: TraitPredicate(<for<'a> fn(&'a u8) -> bool as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrAnon)] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<std::ops::Range<u8> as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1), Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::iter::Step>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ │ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐impl_exprs obligations=[]
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::iter::Step>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrAnon)] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::ops::FnMut<(&u8,)>>, bound_vars: [Region(BrAnon)] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::vec::Vec<u8> as std::iter::FromIterator<u8>>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::vec::Vec<u8> as std::iter::FromIterator<u8>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[Obligation(predicate=Binder { value: TraitPredicate(<u8 as std::marker::Sized>, polarity:Positive), bound_vars: [] }, depth=1)]
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::iter::Filter<std::ops::Range<u8>, for<'a> fn(&'a u8) -> bool> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::iter::Filter<std::ops::Range<u8>, for<'a> fn(&'a u8) -> bool> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <std::ops::Range<u8> as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <for<'a> fn(&'a u8) -> bool as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <u8 as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+disabled backtrace
+┐impl_expr self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }, target=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ ├─┘
+├─┘
+├─┐sinto self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }
+2024-07-23T15:13:24.497635Z TRACE impl_expr{self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }}:sinto{self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }}: hax_frontend_exporter::traits: frontend/exporter/src/traits.rs:3: Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ ├─  0ms TRACE Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: ProjectionPredicate(AliasTerm { args: [P/#0, (&'^0.Named(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), "'_") u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+disabled backtrace
+├─┐impl_expr self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }, target=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐sinto self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }
+2024-07-23T15:13:24.498135Z TRACE predicate_id{self=Binder { value: ProjectionPredicate(AliasTerm { args: [P/#0, (&'^0.Named(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), "'_") u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }}:impl_expr{self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }}:sinto{self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }}: hax_frontend_exporter::traits: frontend/exporter/src/traits.rs:3: Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ │ ├─  0ms TRACE Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+disabled backtrace
+┐impl_expr self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }, target=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ ├─┘
+├─┘
+├─┐sinto self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }
+2024-07-23T15:13:24.498810Z TRACE impl_expr{self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }}:sinto{self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }}: hax_frontend_exporter::traits: frontend/exporter/src/traits.rs:3: Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ ├─  0ms TRACE Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: ProjectionPredicate(AliasTerm { args: [P/#0, (&'^0.Named(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), "'_") u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+disabled backtrace
+├─┐impl_expr self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }, target=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐sinto self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }
+2024-07-23T15:13:24.499262Z TRACE predicate_id{self=Binder { value: ProjectionPredicate(AliasTerm { args: [P/#0, (&'^0.Named(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), "'_") u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }}:impl_expr{self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }}:sinto{self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }}: hax_frontend_exporter::traits: frontend/exporter/src/traits.rs:3: Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ │ ├─  0ms TRACE Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<OP as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<OP as unconstrainted_types_issue_677::PolyOp>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <OP as unconstrainted_types_issue_677::PolyOp>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <OP as unconstrainted_types_issue_677::PolyOp>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<OP as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <OP as unconstrainted_types_issue_677::PolyOp>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<OP as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<OP as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<OP as unconstrainted_types_issue_677::PolyOp>, polarity:Positive), bound_vars: [] }, target=Binder { value: <OP as unconstrainted_types_issue_677::PolyOp>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<OP as unconstrainted_types_issue_677::PolyOp>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <unconstrainted_types_issue_677::Plus as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <unconstrainted_types_issue_677::Plus as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <unconstrainted_types_issue_677::Plus as unconstrainted_types_issue_677::PolyOp>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <unconstrainted_types_issue_677::Plus as unconstrainted_types_issue_677::PolyOp>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <unconstrainted_types_issue_677::Times as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <unconstrainted_types_issue_677::Times as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <unconstrainted_types_issue_677::Times as unconstrainted_types_issue_677::PolyOp>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <unconstrainted_types_issue_677::Times as unconstrainted_types_issue_677::PolyOp>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<OP as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<OP as unconstrainted_types_issue_677::PolyOp>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <OP as unconstrainted_types_issue_677::PolyOp>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <OP as unconstrainted_types_issue_677::PolyOp>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<OP as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <OP as unconstrainted_types_issue_677::PolyOp>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<OP as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<OP as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<OP as unconstrainted_types_issue_677::PolyOp>, polarity:Positive), bound_vars: [] }, target=Binder { value: <OP as unconstrainted_types_issue_677::PolyOp>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<OP as unconstrainted_types_issue_677::PolyOp>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <unconstrainted_types_issue_677::Plus as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <unconstrainted_types_issue_677::Plus as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <unconstrainted_types_issue_677::Plus as unconstrainted_types_issue_677::PolyOp>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <unconstrainted_types_issue_677::Plus as unconstrainted_types_issue_677::PolyOp>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <unconstrainted_types_issue_677::Times as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <unconstrainted_types_issue_677::Times as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <unconstrainted_types_issue_677::Times as unconstrainted_types_issue_677::PolyOp>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <unconstrainted_types_issue_677::Times as unconstrainted_types_issue_677::PolyOp>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <implicit_dependencies_issue_667::define_type::MyType as implicit_dependencies_issue_667::trait_definition::MyTrait>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <implicit_dependencies_issue_667::define_type::MyType as implicit_dependencies_issue_667::trait_definition::MyTrait>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <implicit_dependencies_issue_667::define_type::MyType as implicit_dependencies_issue_667::trait_definition::MyTrait>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <implicit_dependencies_issue_667::define_type::MyType as implicit_dependencies_issue_667::trait_definition::MyTrait>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <implicit_dependencies_issue_667::define_type::MyType as implicit_dependencies_issue_667::trait_definition::MyTrait>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <implicit_dependencies_issue_667::define_type::MyType as implicit_dependencies_issue_667::trait_definition::MyTrait>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(FooConst/#0, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<FooType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(FooConst/#1, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<FooType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(FooConst/#1, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<FooType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(FunConst/#3, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<FunType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(FooConst/#0, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<FooType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<SelfType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(FunConst/#3, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<FunType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(FooConst/#0, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<FooType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(FooConst/#1, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<FooType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(FooConst/#1, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<FooType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(FunConst/#3, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<FunType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(FooConst/#0, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<FooType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<SelfType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(FunConst/#3, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<FunType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(ConstArg/#1, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(ConstArg/#2, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(ConstArg/#2, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(MethodConstArg/#4, usize), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(MethodConstArg/#4, usize), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(ConstArg/#1, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(MethodConstArg/#3, usize), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(MethodConstArg/#3, usize), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(ConstArg/#2, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(ConstArg/#2, usize), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>::AssocType as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>::AssocType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>::AssocType as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>::AssocType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(ConstArg/#2, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(MethodConstArg/#3, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<ImplTrait as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<ImplTrait as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<ImplTrait as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<ImplTrait as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <MethodTypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <MethodTypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <MethodTypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(ConstArg/#2, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(MethodConstArg/#3, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<ImplTrait as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<ImplTrait as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<ImplTrait as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<ImplTrait as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <MethodTypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <MethodTypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <MethodTypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(ConstArg/#1, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(ConstArg/#2, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(ConstArg/#2, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(MethodConstArg/#4, usize), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(MethodConstArg/#4, usize), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(ConstArg/#1, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(MethodConstArg/#3, usize), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(MethodConstArg/#3, usize), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(ConstArg/#2, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(ConstArg/#2, usize), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>::AssocType as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>::AssocType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>::AssocType as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐impl_expr self=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>::AssocType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <Self as implicit_explicit_calling_conventions::SubTrait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(ConstArg/#2, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(MethodConstArg/#3, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<ImplTrait as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<ImplTrait as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<ImplTrait as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<ImplTrait as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <MethodTypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <MethodTypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <MethodTypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(ConstArg/#2, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(MethodConstArg/#3, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<ImplTrait as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<ImplTrait as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<ImplTrait as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<ImplTrait as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<ImplTrait as implicit_explicit_calling_conventions::Trait<TypeArg, ConstArg>>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <MethodTypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <MethodTypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <MethodTypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<MethodTypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <TypeArg as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::clone::Clone>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::clone::Clone>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<TypeArg as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(ConstArg/#1, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: ConstArgHasType(FooConst/#0, usize), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<FooType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<SelfType as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <P as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <P as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <P as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <P as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <P as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <P as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+disabled backtrace
+warning[E9999]: Hax frontend found a projected type with escaping bound vars. Please report https://github.com/hacspec/hax/issues/495
+                
+                Context:
+                 - alias_ty: AliasTy {
+                    args: [
+                        P/#1,
+                        (&'^0.Named(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), "'_") Alias(Projection, AliasTy { args: [I/#0], def_id: DefId(2:8504 ~ core[fd5e]::iter::traits::iterator::Iterator::Item) }),),
+                    ],
+                    def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output),
+                }
+                 - alias_kind: Projection
+                 - trait_ref: <P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>
+                 - trait_ref_and_generics: (
+                    <P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>,
+                    [],
+                )
+                 - rebased_generics: [
+                    P/#1,
+                    (&'^0.Named(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), "'_") Alias(Projection, AliasTy { args: [I/#0], def_id: DefId(2:8504 ~ core[fd5e]::iter::traits::iterator::Iterator::Item) }),),
+                    (&'^0.Named(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), "'_") Alias(Projection, AliasTy { args: [I/#0], def_id: DefId(2:8504 ~ core[fd5e]::iter::traits::iterator::Iterator::Item) }),),
+                ]
+                 - norm_rebased_generics: Err(
+                    Type(
+                        (&'^0.Named(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), "'_") Alias(Projection, AliasTy { args: [P/#1], def_id: DefId(2:8504 ~ core[fd5e]::iter::traits::iterator::Iterator::Item) }),),
+                    ),
+                )
+                 - norm_generics: Err(
+                    Type(
+                        (&'^0.Named(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), "'_") Alias(Projection, AliasTy { args: [P/#1], def_id: DefId(2:8504 ~ core[fd5e]::iter::traits::iterator::Iterator::Item) }),),
+                    ),
+                )
+                 - early_binder_generics: Ok(
+                    <(&<I as std::iter::Iterator>::Item,) as std::ops::FnOnce<(&<P as std::iter::Iterator>::Item,)>>,
+                )
+                 - early_binder_rebased_generics: Ok(
+                    <(&<I as std::iter::Iterator>::Item,) as std::ops::FnOnce<(&<P as std::iter::Iterator>::Item,)>>,
+                )
+  --> /home/maxime/.rustup/toolchains/nightly-2024-06-25-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/iter/adapters/filter.rs:52:1
+   |
+52 | / impl<I: Iterator, P> Iterator for Filter<I, P>
+53 | | where
+54 | |     P: FnMut(&I::Item) -> bool,
+   | |_______________________________^
+   |
+   = note: ⚠️ This is a bug in Hax's frontend.
+           Please report this error to https://github.com/hacspec/hax/issues with some context (e.g. the current crate)!
+
+┐impl_expr self=Binder { value: <P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }, target=Binder { value: <P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐sinto self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }, index: 0 }
+2024-07-23T15:13:24.529944Z TRACE impl_expr{self=Binder { value: <P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }}:sinto{self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }, index: 0 }}: hax_frontend_exporter::traits: frontend/exporter/src/traits.rs:3: Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ ├─  0ms TRACE Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ ├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┐trace_span2 
+│ │ │ │ │ │ ├─┐trace_span3 
+│ │ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ │ ├─┘
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐impl_exprs obligations=[]
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ ├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: ProjectionPredicate(AliasTerm { args: [P/#1, (&'^0.Named(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), "'_") Alias(Projection, AliasTy { args: [I/#0], def_id: DefId(2:8504 ~ core[fd5e]::iter::traits::iterator::Iterator::Item) }),)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+disabled backtrace
+├─┐impl_expr self=Binder { value: <P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }, target=Binder { value: <P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐sinto self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }, index: 0 }
+2024-07-23T15:13:24.531909Z TRACE predicate_id{self=Binder { value: ProjectionPredicate(AliasTerm { args: [P/#1, (&'^0.Named(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), "'_") Alias(Projection, AliasTy { args: [I/#0], def_id: DefId(2:8504 ~ core[fd5e]::iter::traits::iterator::Iterator::Item) }),)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }}:impl_expr{self=Binder { value: <P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }}:sinto{self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }, index: 0 }}: hax_frontend_exporter::traits: frontend/exporter/src/traits.rs:3: Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ │ ├─  0ms TRACE Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ │ ├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐trace_span2 
+│ │ │ │ │ ├─┐trace_span3 
+│ │ │ │ │ ├─┘
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐impl_exprs obligations=[]
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }
+│ │ │ │ ├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ │ │ ├─┘
+│ │ │ │ │ │ ├─┐trace_span2 
+│ │ │ │ │ │ │ ├─┐trace_span3 
+│ │ │ │ │ │ │ ├─┘
+│ │ │ │ │ │ ├─┘
+│ │ │ │ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┐impl_exprs obligations=[]
+│ │ │ │ │ ├─┘
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+│ │ ├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐trace_span2 
+│ │ │ │ │ ├─┐trace_span3 
+│ │ │ │ │ ├─┘
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐impl_exprs obligations=[]
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(2:54501 ~ core[fd5e]::iter::adapters::filter::{impl#2}::'_), '_))] }
+├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <T as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <T as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <A as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <A as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <A as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<A as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <A as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<A as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <A as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <A as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <A as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<A as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <A as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<A as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<A as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<A as std::alloc::Allocator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <A as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<A as std::alloc::Allocator>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <T as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <T as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <A as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <A as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <A as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<A as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <A as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<A as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <A as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <A as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <A as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<A as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <A as std::alloc::Allocator>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<A as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<A as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<A as std::alloc::Allocator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <A as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<A as std::alloc::Allocator>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<A as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<A as std::alloc::Allocator>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<A as std::cmp::PartialEq<B>>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <T as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <T as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <T as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <T as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::marker::Sized>, bound_vars: [] }
+├─┘
+┘
+┐impl_expr self=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <std::alloc::Global as std::alloc::Allocator>, bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <T as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <T as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <T as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <T as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <T as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <A as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <A as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<A as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <A as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<A as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <A as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <A as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<A as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <A as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<A as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<A as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<A as std::iter::Step>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::marker::Sized>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐select_trait_candidate trait_ref=Binder { value: <F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::ops::FnMut<(<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::ops::FnMut<(<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::ops::FnMut<(<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐sinto self=Parent { predicate: Binder { value: TraitPredicate(<F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }, index: 0 }
+2024-07-23T15:13:24.537800Z TRACE impl_expr{self=Binder { value: <F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }}:sinto{self=Parent { predicate: Binder { value: TraitPredicate(<F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }, index: 0 }}: hax_frontend_exporter::traits: frontend/exporter/src/traits.rs:3: Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ ├─  0ms TRACE Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ ├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┐trace_span2 
+│ │ │ │ │ │ ├─┐trace_span3 
+│ │ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ │ ├─┘
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┐trace_span2 
+│ │ │ │ │ │ ├─┐trace_span3 
+│ │ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ │ ├─┘
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐impl_exprs obligations=[]
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::ops::FnMut<(<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: ProjectionPredicate(AliasTerm { args: [F/#2, (Alias(Projection, AliasTy { args: [I/#1], def_id: DefId(2:8504 ~ core[fd5e]::iter::traits::iterator::Iterator::Item) }),)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(B/#0)), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+│ ├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::ops::FnMut<(<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }, target=Binder { value: <F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::ops::FnMut<(<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::ops::FnMut<(<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐trace_span2 
+│ │ │ │ ├─┐trace_span3 
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐impl_exprs obligations=[]
+│ │ ├─┘
+│ ├─┘
+│ ├─┐sinto self=Parent { predicate: Binder { value: TraitPredicate(<F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }, index: 0 }
+2024-07-23T15:13:24.540219Z TRACE predicate_id{self=Binder { value: ProjectionPredicate(AliasTerm { args: [F/#2, (Alias(Projection, AliasTy { args: [I/#1], def_id: DefId(2:8504 ~ core[fd5e]::iter::traits::iterator::Iterator::Item) }),)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(B/#0)), bound_vars: [] }}:impl_expr{self=Binder { value: <F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, bound_vars: [] }}:sinto{self=Parent { predicate: Binder { value: TraitPredicate(<F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }, index: 0 }}: hax_frontend_exporter::traits: frontend/exporter/src/traits.rs:3: Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ │ ├─  0ms TRACE Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ │ ├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐trace_span2 
+│ │ │ │ │ ├─┐trace_span3 
+│ │ │ │ │ ├─┘
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐trace_span2 
+│ │ │ │ │ ├─┐trace_span3 
+│ │ │ │ │ ├─┘
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐impl_exprs obligations=[]
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::ops::FnOnce<(<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }
+│ │ │ │ ├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ │ │ ├─┘
+│ │ │ │ │ │ ├─┐trace_span2 
+│ │ │ │ │ │ │ ├─┐trace_span3 
+│ │ │ │ │ │ │ ├─┘
+│ │ │ │ │ │ ├─┘
+│ │ │ │ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ │ │ ├─┘
+│ │ │ │ │ │ ├─┐trace_span2 
+│ │ │ │ │ │ │ ├─┐trace_span3 
+│ │ │ │ │ │ │ ├─┘
+│ │ │ │ │ │ ├─┘
+│ │ │ │ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ │ │ │ ├─┘
+│ │ │ │ │ ├─┐impl_exprs obligations=[]
+│ │ │ │ │ ├─┘
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<F as std::ops::FnMut<(<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐trace_span2 
+│ │ │ │ │ ├─┐trace_span3 
+│ │ │ │ │ ├─┘
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐trace_span2 
+│ │ │ │ │ ├─┐trace_span3 
+│ │ │ │ │ ├─┘
+│ │ │ │ ├─┘
+│ │ │ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ │ │ ├─┘
+│ │ │ ├─┘
+│ │ │ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ │ ├─┐impl_exprs obligations=[]
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+┘
+┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<F as std::ops::FnMut<(<I as std::iter::Iterator>::Item,)>>, polarity:Positive), bound_vars: [] }
+├─┐impl_expr self=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<I as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<F as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }, target=Binder { value: <I as std::iter::Iterator>, bound_vars: [] }
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<I as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<B as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+disabled backtrace
+┐impl_expr self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+├─┐select_trait_candidate trait_ref=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+├─┘
+├─┐path_to self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }, target=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐trace_span2 
+│ │ ├─┐trace_span3 
+│ │ ├─┘
+│ ├─┘
+│ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ ├─┘
+├─┘
+├─┐sinto self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }
+2024-07-23T15:13:24.542553Z TRACE impl_expr{self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }}:sinto{self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }}: hax_frontend_exporter::traits: frontend/exporter/src/traits.rs:3: Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ ├─  0ms TRACE Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ ├─┘
+│ ├─┘
+├─┘
+├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+├─┘
+├─┐impl_exprs obligations=[]
+├─┘
+┘
+┐predicate_id self=Binder { value: ProjectionPredicate(AliasTerm { args: [P/#0, (&'^0.Named(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), "'_") u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+disabled backtrace
+├─┐impl_expr self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ ├─┐select_trait_candidate trait_ref=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ ├─┘
+│ ├─┐path_to self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }, target=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }
+│ │ ├─┐parents_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐trace_span2 
+│ │ │ ├─┐trace_span3 
+│ │ │ ├─┘
+│ │ ├─┘
+│ │ ├─┐associated_items_trait_predicates self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ │ ├─┘
+│ ├─┘
+│ ├─┐sinto self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }
+2024-07-23T15:13:24.543035Z TRACE predicate_id{self=Binder { value: ProjectionPredicate(AliasTerm { args: [P/#0, (&'^0.Named(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), "'_") u8,)], def_id: DefId(2:3496 ~ core[fd5e]::ops::function::FnOnce::Output) }, Term::Ty(bool)), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }}:impl_expr{self=Binder { value: <P as std::ops::FnOnce<(&u8,)>>, bound_vars: [] }}:sinto{self=Parent { predicate: Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }, index: 0 }}: hax_frontend_exporter::traits: frontend/exporter/src/traits.rs:3: Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ │ ├─  0ms TRACE Enters sinto (search_clause :: PathChunk < 'tcx >)
+│ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnOnce<(&u8,)>>, polarity:Positive), bound_vars: [] }
+│ │ │ ├─┘
+│ │ ├─┘
+│ ├─┘
+│ ├─┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+│ ├─┘
+│ ├─┐impl_exprs obligations=[]
+│ ├─┘
+├─┘
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<P as std::ops::FnMut<(&u8,)>>, polarity:Positive), bound_vars: [Region(BrNamed(DefId(0:172 ~ traits[3797]::for_clauses::issue_495::minimized_3::{impl#0}::'_), '_))] }
+┘
+┐predicate_id self=Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+┘
+warning: `traits` (lib) generated 2 warnings
+    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.60s
+info: hax: wrote file /home/maxime/cryspen/hax/tests/traits/proofs/fstar/extraction/Traits.fst
+info: hax: wrote file /home/maxime/cryspen/hax/tests/traits/proofs/fstar/extraction/Traits.For_clauses.fst
+info: hax: wrote file /home/maxime/cryspen/hax/tests/traits/proofs/fstar/extraction/Traits.For_clauses.Issue_495_.fst
+info: hax: wrote file /home/maxime/cryspen/hax/tests/traits/proofs/fstar/extraction/Traits.For_clauses.Issue_495_.Minimized_3_.fst
+info: hax: wrote file /home/maxime/cryspen/hax/tests/traits/proofs/fstar/extraction/Traits.Implicit_dependencies_issue_667_.Define_type.fst
+info: hax: wrote file /home/maxime/cryspen/hax/tests/traits/proofs/fstar/extraction/Traits.Implicit_dependencies_issue_667_.Impl_type.fst
+info: hax: wrote file /home/maxime/cryspen/hax/tests/traits/proofs/fstar/extraction/Traits.Implicit_dependencies_issue_667_.Trait_definition.fst
+info: hax: wrote file /home/maxime/cryspen/hax/tests/traits/proofs/fstar/extraction/Traits.Implicit_dependencies_issue_667_.Use_type.fst
+info: hax: wrote file /home/maxime/cryspen/hax/tests/traits/proofs/fstar/extraction/Traits.Implicit_explicit_calling_conventions.fst
+info: hax: wrote file /home/maxime/cryspen/hax/tests/traits/proofs/fstar/extraction/Traits.Interlaced_consts_types.fst
+info: hax: wrote file /home/maxime/cryspen/hax/tests/traits/proofs/fstar/extraction/Traits.Type_alias_bounds_issue_707_.fst
+info: hax: wrote file /home/maxime/cryspen/hax/tests/traits/proofs/fstar/extraction/Traits.Unconstrainted_types_issue_677_.fst
diff --git a/tests/traits/src/lib.rs b/tests/traits/src/lib.rs
index 4013b9f3d..a81df90d3 100644
--- a/tests/traits/src/lib.rs
+++ b/tests/traits/src/lib.rs
@@ -253,3 +253,15 @@ mod type_alias_bounds_issue_707 {
     type SynonymA<T> = StructWithGenericBounds<T>;
     type SynonymB<T> = StructWithGenericBounds<(T, T)>;
 }
+
+// Related to PR 730
+mod block_size {
+    pub trait BlockSizeUser {
+        type BlockSize;
+    }
+    pub trait ParBlocksSizeUser: BlockSizeUser {}
+
+    pub trait BlockBackend: ParBlocksSizeUser {
+        fn proc_block(block: Vec<<Self as BlockSizeUser>::BlockSize>);
+    }
+}